posthog-node 2.0.0-alpha9 → 2.1.0

package/lib/index.esm.js

@@ -1,4 +1,5 @@
-import undici from 'undici';
+import { createHash } from 'crypto';
+import axios from 'axios';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -42,6 +43,18 @@ var __assign = function () {
     };
     return __assign.apply(this, arguments);
 };
+function __rest(s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -129,9 +142,20 @@ function __generator(thisArg, body) {
             throw op[1];
         return { value: op[0] ? op[1] : void 0, done: true };
     }
+}
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar)
+                    ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+    return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "2.0.0-alpha9";
+var version = "2.1.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -144,6 +168,8 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["OptedOut"] = "opted_out";
     PostHogPersistedProperty["SessionId"] = "session_id";
     PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
+    PostHogPersistedProperty["PersonProperties"] = "person_properties";
+    PostHogPersistedProperty["GroupProperties"] = "group_properties";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 
 function assert(truthyValue, message) {
@@ -717,12 +743,14 @@ var PostHogCore = /** @class */ (function () {
     }
     PostHogCore.prototype.getCommonEventProperties = function () {
         var featureFlags = this.getFeatureFlags();
-        return {
-            $lib: this.getLibraryId(),
-            $lib_version: this.getLibraryVersion(),
-            $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined,
-            $enabled_feature_flags: featureFlags,
-        };
+        var featureVariantProperties = {};
+        if (featureFlags) {
+            for (var _i = 0, _a = Object.entries(featureFlags); _i < _a.length; _i++) {
+                var _b = _a[_i], feature = _b[0], variant = _b[1];
+                featureVariantProperties["$feature/".concat(feature)] = variant;
+            }
+        }
+        return __assign({ $lib: this.getLibraryId(), $lib_version: this.getLibraryVersion(), $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined }, featureVariantProperties);
     };
     Object.defineProperty(PostHogCore.prototype, "props", {
         // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
@@ -738,6 +766,9 @@ var PostHogCore = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    PostHogCore.prototype.clearProps = function () {
+        this.props = undefined;
+    };
     Object.defineProperty(PostHogCore.prototype, "optedOut", {
         get: function () {
             var _a, _b;
@@ -755,9 +786,15 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.on = function (event, cb) {
         return this._events.on(event, cb);
     };
-    PostHogCore.prototype.reset = function () {
-        for (var key in PostHogPersistedProperty) {
-            this.setPersistedProperty(PostHogPersistedProperty[key], null);
+    PostHogCore.prototype.reset = function (propertiesToKeep) {
+        var allPropertiesToKeep = __spreadArray([PostHogPersistedProperty.Queue], (propertiesToKeep || []), true);
+        // clean up props
+        this.clearProps();
+        for (var _i = 0, _a = Object.keys(PostHogPersistedProperty); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (!allPropertiesToKeep.includes(PostHogPersistedProperty[key])) {
+                this.setPersistedProperty(PostHogPersistedProperty[key], null);
+            }
         }
     };
     PostHogCore.prototype.debug = function (enabled) {
@@ -832,12 +869,18 @@ var PostHogCore = /** @class */ (function () {
         this.enqueue('identify', payload);
         return this;
     };
-    PostHogCore.prototype.capture = function (event, properties) {
+    PostHogCore.prototype.capture = function (event, properties, forceSendFeatureFlags) {
+        if (forceSendFeatureFlags === void 0) { forceSendFeatureFlags = false; }
         if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
             this.groups(properties.$groups);
         }
-        var payload = this.buildPayload({ event: event, properties: properties });
-        this.enqueue('capture', payload);
+        if (forceSendFeatureFlags) {
+            this._sendFeatureFlags(event, properties);
+        }
+        else {
+            var payload = this.buildPayload({ event: event, properties: properties });
+            this.enqueue('capture', payload);
+        }
         return this;
     };
     PostHogCore.prototype.alias = function (alias) {
@@ -867,7 +910,6 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.groups = function (groups) {
         // Get persisted groups
         var existingGroups = this.props.$groups || {};
-        // NOTE: Should we do the same for groups listed in identify / capture?
         this.register({
             $groups: __assign(__assign({}, existingGroups), groups),
         });
@@ -895,31 +937,58 @@ var PostHogCore = /** @class */ (function () {
         this.enqueue('capture', payload);
         return this;
     };
+    /***
+     * PROPERTIES
+     ***/
+    PostHogCore.prototype.personProperties = function (properties) {
+        // Get persisted person properties
+        var existingProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+        this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, __assign(__assign({}, existingProperties), properties));
+        return this;
+    };
+    PostHogCore.prototype.groupProperties = function (properties) {
+        // Get persisted group properties
+        var existingProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
+        if (Object.keys(existingProperties).length !== 0) {
+            Object.keys(existingProperties).forEach(function (groupType) {
+                existingProperties[groupType] = __assign(__assign({}, existingProperties[groupType]), properties[groupType]);
+                delete properties[groupType];
+            });
+        }
+        this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, __assign(__assign({}, existingProperties), properties));
+        return this;
+    };
     /***
      *** FEATURE FLAGS
      ***/
-    PostHogCore.prototype.decideAsync = function () {
+    PostHogCore.prototype.decideAsync = function (sendAnonDistinctId) {
+        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         if (this._decideResponsePromise) {
             return this._decideResponsePromise;
         }
-        return this._decideAsync();
+        return this._decideAsync(sendAnonDistinctId);
     };
-    PostHogCore.prototype._decideAsync = function () {
+    PostHogCore.prototype._decideAsync = function (sendAnonDistinctId) {
+        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         return __awaiter(this, void 0, void 0, function () {
-            var url, distinctId, groups, fetchOptions;
+            var url, distinctId, groups, personProperties, groupProperties, fetchOptions;
             var _this = this;
             return __generator(this, function (_a) {
                 url = "".concat(this.host, "/decide/?v=2");
                 distinctId = this.getDistinctId();
                 groups = this.props.$groups || {};
+                personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+                groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
                 fetchOptions = {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({
                         token: this.apiKey,
                         distinct_id: distinctId,
-                        $anon_distinct_id: this.getAnonymousId(),
+                        $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
                         groups: groups,
+                        person_properties: personProperties,
+                        group_properties: groupProperties,
                     }),
                 };
                 this._decideResponsePromise = this.fetchWithRetry(url, fetchOptions)
@@ -938,23 +1007,26 @@ var PostHogCore = /** @class */ (function () {
             });
         });
     };
-    PostHogCore.prototype.getFeatureFlag = function (key, defaultResult) {
-        var _a;
-        if (defaultResult === void 0) { defaultResult = false; }
+    PostHogCore.prototype.getFeatureFlag = function (key) {
         var featureFlags = this.getFeatureFlags();
         if (!featureFlags) {
-            // If we haven't loaded flags yet we respond undefined to indicate this
+            // If we haven't loaded flags yet, or errored out, we respond with undefined
             return undefined;
         }
+        var response = featureFlags[key];
+        if (response === undefined) {
+            // `/decide` returns nothing for flags which are false.
+            response = false;
+        }
         if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
             this.flagCallReported[key] = true;
             this.capture('$feature_flag_called', {
                 $feature_flag: key,
-                $feature_flag_response: featureFlags[key],
+                $feature_flag_response: response,
             });
         }
-        // If we have flags we either return the value (true or string) or the defaultResult
-        return (_a = featureFlags[key]) !== null && _a !== void 0 ? _a : defaultResult;
+        // If we have flags we either return the value (true or string) or false
+        return response;
     };
     PostHogCore.prototype.getFeatureFlags = function () {
         var flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
@@ -973,17 +1045,19 @@ var PostHogCore = /** @class */ (function () {
         }
         return flags;
     };
-    PostHogCore.prototype.isFeatureEnabled = function (key, defaultResult) {
-        var _a;
-        if (defaultResult === void 0) { defaultResult = false; }
-        var flag = (_a = this.getFeatureFlag(key, defaultResult)) !== null && _a !== void 0 ? _a : defaultResult;
-        return !!flag;
+    PostHogCore.prototype.isFeatureEnabled = function (key) {
+        var response = this.getFeatureFlag(key);
+        if (response === undefined) {
+            return undefined;
+        }
+        return !!response;
     };
-    PostHogCore.prototype.reloadFeatureFlagsAsync = function () {
+    PostHogCore.prototype.reloadFeatureFlagsAsync = function (sendAnonDistinctId) {
+        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.decideAsync()];
+                    case 0: return [4 /*yield*/, this.decideAsync(sendAnonDistinctId)];
                     case 1: return [2 /*return*/, (_a.sent()).featureFlags];
                 }
             });
@@ -1021,6 +1095,14 @@ var PostHogCore = /** @class */ (function () {
         }
         return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
     };
+    PostHogCore.prototype._sendFeatureFlags = function (event, properties) {
+        var _this = this;
+        this.reloadFeatureFlagsAsync(false).finally(function () {
+            // Try to enqueue message irrespective of errors during feature flag fetching
+            var payload = _this.buildPayload({ event: event, properties: properties });
+            _this.enqueue('capture', payload);
+        });
+    };
     /***
      *** QUEUEING AND FLUSHING
      ***/
@@ -1049,13 +1131,15 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.flushAsync = function () {
         var _this = this;
         return new Promise(function (resolve, reject) {
-            _this.flush(function (err, data) { return (err ? reject(err) : resolve(data)); });
+            _this.flush(function (err, data) {
+                return err ? reject(err) : resolve(data);
+            });
         });
     };
     PostHogCore.prototype.flush = function (callback) {
         var _this = this;
         if (this.optedOut) {
-            return callback && safeSetTimeout(callback, 0);
+            return callback === null || callback === void 0 ? void 0 : callback();
         }
         if (this._flushTimer) {
             clearTimeout(this._flushTimer);
@@ -1063,7 +1147,7 @@ var PostHogCore = /** @class */ (function () {
         }
         var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
         if (!queue.length) {
-            return callback && safeSetTimeout(callback, 0);
+            return callback === null || callback === void 0 ? void 0 : callback();
         }
         var items = queue.splice(0, this.flushAt);
         this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
@@ -1150,12 +1234,608 @@ var PostHogMemoryStorage = /** @class */ (function () {
     return PostHogMemoryStorage;
 }());
 
-var PostHog =
+// So that alternative implementations can be used if desired
+
+var fetch = function (url, options) {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var res;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          return [4
+          /*yield*/
+          , axios.request({
+            url: url,
+            headers: options.headers,
+            method: options.method.toLowerCase(),
+            data: options.body,
+            signal: options.signal
+          })];
+
+        case 1:
+          res = _a.sent();
+          return [2
+          /*return*/
+          , {
+            status: res.status,
+            text: function () {
+              return res.data;
+            },
+            json: function () {
+              return res.data;
+            }
+          }];
+      }
+    });
+  });
+};
+
+var LONG_SCALE = 0xfffffffffffffff;
+
+var ClientError =
 /** @class */
 function (_super) {
-  __extends(PostHog, _super);
+  __extends(ClientError, _super);
 
-  function PostHog(apiKey, options) {
+  function ClientError(message) {
+    var _this = _super.call(this) || this;
+
+    Error.captureStackTrace(_this, _this.constructor);
+    _this.name = 'ClientError';
+    _this.message = message;
+    Object.setPrototypeOf(_this, ClientError.prototype);
+    return _this;
+  }
+
+  return ClientError;
+}(Error);
+
+var InconclusiveMatchError =
+/** @class */
+function (_super) {
+  __extends(InconclusiveMatchError, _super);
+
+  function InconclusiveMatchError(message) {
+    var _this = _super.call(this, message) || this;
+
+    _this.name = _this.constructor.name;
+    Error.captureStackTrace(_this, _this.constructor); // instanceof doesn't work in ES3 or ES5
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    // this is the workaround
+
+    Object.setPrototypeOf(_this, InconclusiveMatchError.prototype);
+    return _this;
+  }
+
+  return InconclusiveMatchError;
+}(Error);
+
+var FeatureFlagsPoller =
+/** @class */
+function () {
+  function FeatureFlagsPoller(_a) {
+    var pollingInterval = _a.pollingInterval,
+        personalApiKey = _a.personalApiKey,
+        projectApiKey = _a.projectApiKey,
+        timeout = _a.timeout,
+        host = _a.host,
+        options = __rest(_a, ["pollingInterval", "personalApiKey", "projectApiKey", "timeout", "host"]);
+
+    this.pollingInterval = pollingInterval;
+    this.personalApiKey = personalApiKey;
+    this.featureFlags = [];
+    this.groupTypeMapping = {};
+    this.loadedSuccessfullyOnce = false;
+    this.timeout = timeout;
+    this.projectApiKey = projectApiKey;
+    this.host = host;
+    this.poller = undefined; // NOTE: as any is required here as the AbortSignal typing is slightly misaligned but works just fine
+
+    this.fetch = options.fetch || fetch;
+    void this.loadFeatureFlags();
+  }
+
+  FeatureFlagsPoller.prototype.getFeatureFlag = function (key, distinctId, groups, personProperties, groupProperties) {
+    if (groups === void 0) {
+      groups = {};
+    }
+
+    if (personProperties === void 0) {
+      personProperties = {};
+    }
+
+    if (groupProperties === void 0) {
+      groupProperties = {};
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      var response, featureFlag, _i, _a, flag;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this.loadFeatureFlags()];
+
+          case 1:
+            _b.sent();
+
+            response = undefined;
+            featureFlag = undefined;
+
+            if (!this.loadedSuccessfullyOnce) {
+              return [2
+              /*return*/
+              , response];
+            }
+
+            for (_i = 0, _a = this.featureFlags; _i < _a.length; _i++) {
+              flag = _a[_i];
+
+              if (key === flag.key) {
+                featureFlag = flag;
+                break;
+              }
+            }
+
+            if (featureFlag !== undefined) {
+              try {
+                response = this.computeFlagLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+                console.debug("Successfully computed flag locally: ".concat(key, " -> ").concat(response));
+              } catch (e) {
+                if (e instanceof InconclusiveMatchError) {
+                  console.debug("Can't compute flag locally: ".concat(key, ": ").concat(e));
+                } else if (e instanceof Error) {
+                  console.error("Error computing flag locally: ".concat(key, ": ").concat(e));
+                }
+              }
+            }
+
+            return [2
+            /*return*/
+            , response];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype.getAllFlags = function (distinctId, groups, personProperties, groupProperties) {
+    if (groups === void 0) {
+      groups = {};
+    }
+
+    if (personProperties === void 0) {
+      personProperties = {};
+    }
+
+    if (groupProperties === void 0) {
+      groupProperties = {};
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      var response, fallbackToDecide;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this.loadFeatureFlags()];
+
+          case 1:
+            _a.sent();
+
+            response = {};
+            fallbackToDecide = this.featureFlags.length == 0;
+            this.featureFlags.map(function (flag) {
+              try {
+                response[flag.key] = _this.computeFlagLocally(flag, distinctId, groups, personProperties, groupProperties);
+              } catch (e) {
+                if (e instanceof InconclusiveMatchError) ; else if (e instanceof Error) {
+                  console.error("Error computing flag locally: ".concat(flag.key, ": ").concat(e));
+                }
+
+                fallbackToDecide = true;
+              }
+            });
+            return [2
+            /*return*/
+            , {
+              response: response,
+              fallbackToDecide: fallbackToDecide
+            }];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype.computeFlagLocally = function (flag, distinctId, groups, personProperties, groupProperties) {
+    if (groups === void 0) {
+      groups = {};
+    }
+
+    if (personProperties === void 0) {
+      personProperties = {};
+    }
+
+    if (groupProperties === void 0) {
+      groupProperties = {};
+    }
+
+    if (flag.ensure_experience_continuity) {
+      throw new InconclusiveMatchError('Flag has experience continuity enabled');
+    }
+
+    if (!flag.active) {
+      return false;
+    }
+
+    var flagFilters = flag.filters || {};
+    var aggregation_group_type_index = flagFilters.aggregation_group_type_index;
+
+    if (aggregation_group_type_index != undefined) {
+      var groupName = this.groupTypeMapping[String(aggregation_group_type_index)];
+
+      if (!groupName) {
+        console.warn("[FEATURE FLAGS] Unknown group type index ".concat(aggregation_group_type_index, " for feature flag ").concat(flag.key));
+        throw new InconclusiveMatchError('Flag has unknown group type index');
+      }
+
+      if (!(groupName in groups)) {
+        console.warn("[FEATURE FLAGS] Can't compute group feature flag: ".concat(flag.key, " without group names passed in"));
+        return false;
+      }
+
+      var focusedGroupProperties = groupProperties[groupName];
+      return this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties);
+    } else {
+      return this.matchFeatureFlagProperties(flag, distinctId, personProperties);
+    }
+  };
+
+  FeatureFlagsPoller.prototype.matchFeatureFlagProperties = function (flag, distinctId, properties) {
+    var _this = this;
+
+    var flagFilters = flag.filters || {};
+    var flagConditions = flagFilters.groups || [];
+    var isInconclusive = false;
+    var result = undefined;
+    flagConditions.forEach(function (condition) {
+      try {
+        if (_this.isConditionMatch(flag, distinctId, condition, properties)) {
+          result = _this.getMatchingVariant(flag, distinctId) || true;
+        }
+      } catch (e) {
+        if (e instanceof InconclusiveMatchError) {
+          isInconclusive = true;
+        } else {
+          throw e;
+        }
+      }
+    });
+
+    if (result !== undefined) {
+      return result;
+    } else if (isInconclusive) {
+      throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties");
+    } // We can only return False when all conditions are False
+
+
+    return false;
+  };
+
+  FeatureFlagsPoller.prototype.isConditionMatch = function (flag, distinctId, condition, properties) {
+    var rolloutPercentage = condition.rollout_percentage;
+
+    if ((condition.properties || []).length > 0) {
+      var matchAll = condition.properties.every(function (property) {
+        return matchProperty(property, properties);
+      });
+
+      if (!matchAll) {
+        return false;
+      } else if (rolloutPercentage == undefined) {
+        // == to include `null` as a match, not just `undefined`
+        return true;
+      }
+    }
+
+    if (rolloutPercentage != undefined && _hash(flag.key, distinctId) > rolloutPercentage / 100.0) {
+      return false;
+    }
+
+    return true;
+  };
+
+  FeatureFlagsPoller.prototype.getMatchingVariant = function (flag, distinctId) {
+    var hashValue = _hash(flag.key, distinctId, 'variant');
+
+    var matchingVariant = this.variantLookupTable(flag).find(function (variant) {
+      return hashValue >= variant.valueMin && hashValue < variant.valueMax;
+    });
+
+    if (matchingVariant) {
+      return matchingVariant.key;
+    }
+
+    return undefined;
+  };
+
+  FeatureFlagsPoller.prototype.variantLookupTable = function (flag) {
+    var _a;
+
+    var lookupTable = [];
+    var valueMin = 0;
+    var valueMax = 0;
+    var flagFilters = flag.filters || {};
+    var multivariates = ((_a = flagFilters.multivariate) === null || _a === void 0 ? void 0 : _a.variants) || [];
+    multivariates.forEach(function (variant) {
+      valueMax = valueMin + variant.rollout_percentage / 100.0;
+      lookupTable.push({
+        valueMin: valueMin,
+        valueMax: valueMax,
+        key: variant.key
+      });
+      valueMin = valueMax;
+    });
+    return lookupTable;
+  };
+
+  FeatureFlagsPoller.prototype.loadFeatureFlags = function (forceReload) {
+    if (forceReload === void 0) {
+      forceReload = false;
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (!(!this.loadedSuccessfullyOnce || forceReload)) return [3
+            /*break*/
+            , 2];
+            return [4
+            /*yield*/
+            , this._loadFeatureFlags()];
+
+          case 1:
+            _a.sent();
+
+            _a.label = 2;
+
+          case 2:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype._loadFeatureFlags = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var res, responseJson, err_1;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (this.poller) {
+              clearTimeout(this.poller);
+              this.poller = undefined;
+            }
+
+            this.poller = setTimeout(function () {
+              return _this._loadFeatureFlags();
+            }, this.pollingInterval);
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 4,, 5]);
+
+            return [4
+            /*yield*/
+            , this._requestFeatureFlagDefinitions()];
+
+          case 2:
+            res = _a.sent();
+
+            if (res && res.status === 401) {
+              throw new ClientError("Your personalApiKey is invalid. Are you sure you're not using your Project API key? More information: https://posthog.com/docs/api/overview");
+            }
+
+            return [4
+            /*yield*/
+            , res.json()];
+
+          case 3:
+            responseJson = _a.sent();
+
+            if (!('flags' in responseJson)) {
+              console.error("Invalid response when getting feature flags: ".concat(JSON.stringify(responseJson)));
+            }
+
+            this.featureFlags = responseJson.flags || [];
+            this.groupTypeMapping = responseJson.group_type_mapping || {};
+            this.loadedSuccessfullyOnce = true;
+            return [3
+            /*break*/
+            , 5];
+
+          case 4:
+            err_1 = _a.sent(); // if an error that is not an instance of ClientError is thrown
+            // we silently ignore the error when reloading feature flags
+
+            if (err_1 instanceof ClientError) {
+              throw err_1;
+            }
+
+            return [3
+            /*break*/
+            , 5];
+
+          case 5:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype._requestFeatureFlagDefinitions = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var url, options, abortTimeout, controller_1, err_2;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            url = "".concat(this.host, "/api/feature_flag/local_evaluation?token=").concat(this.projectApiKey);
+            options = {
+              method: 'GET',
+              headers: {
+                'Content-Type': 'application/json',
+                Authorization: "Bearer ".concat(this.personalApiKey),
+                'user-agent': "posthog-node/".concat(version)
+              }
+            };
+            abortTimeout = null;
+
+            if (this.timeout && typeof this.timeout === 'number') {
+              controller_1 = new AbortController();
+              abortTimeout = safeSetTimeout(function () {
+                controller_1.abort();
+              }, this.timeout);
+              options.signal = controller_1.signal;
+            }
+
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 3, 4, 5]);
+
+            return [4
+            /*yield*/
+            , this.fetch(url, options)];
+
+          case 2:
+            return [2
+            /*return*/
+            , _a.sent()];
+
+          case 3:
+            err_2 = _a.sent();
+            throw new Error("Request failed with error: ".concat(err_2));
+
+          case 4:
+            clearTimeout(abortTimeout);
+            return [7
+            /*endfinally*/
+            ];
+
+          case 5:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype.stopPoller = function () {
+    clearTimeout(this.poller);
+  };
+
+  return FeatureFlagsPoller;
+}(); // # This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
+// # Given the same distinct_id and key, it'll always return the same float. These floats are
+// # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
+// # we can do _hash(key, distinct_id) < 0.2
+
+
+function _hash(key, distinctId, salt) {
+  if (salt === void 0) {
+    salt = '';
+  }
+
+  var sha1Hash = createHash('sha1');
+  sha1Hash.update("".concat(key, ".").concat(distinctId).concat(salt));
+  return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE;
+}
+
+function matchProperty(property, propertyValues) {
+  var key = property.key;
+  var value = property.value;
+  var operator = property.operator || 'exact';
+
+  if (!(key in propertyValues)) {
+    throw new InconclusiveMatchError("Property ".concat(key, " not found in propertyValues"));
+  } else if (operator === 'is_not_set') {
+    throw new InconclusiveMatchError("Operator is_not_set is not supported");
+  }
+
+  var overrideValue = propertyValues[key];
+
+  switch (operator) {
+    case 'exact':
+      return Array.isArray(value) ? value.indexOf(overrideValue) !== -1 : value === overrideValue;
+
+    case 'is_not':
+      return Array.isArray(value) ? value.indexOf(overrideValue) === -1 : value !== overrideValue;
+
+    case 'is_set':
+      return key in propertyValues;
+
+    case 'icontains':
+      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+
+    case 'not_icontains':
+      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+
+    case 'regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null;
+
+    case 'not_regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) === null;
+
+    case 'gt':
+      return typeof overrideValue == typeof value && overrideValue > value;
+
+    case 'gte':
+      return typeof overrideValue == typeof value && overrideValue >= value;
+
+    case 'lt':
+      return typeof overrideValue == typeof value && overrideValue < value;
+
+    case 'lte':
+      return typeof overrideValue == typeof value && overrideValue <= value;
+
+    default:
+      console.error("Unknown operator: ".concat(operator));
+      return false;
+  }
+}
+
+function isValidRegex(regex) {
+  try {
+    new RegExp(regex);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+var THIRTY_SECONDS = 30 * 1000;
+var MAX_CACHE_SIZE = 50 * 1000;
+
+var PostHogClient =
+/** @class */
+function (_super) {
+  __extends(PostHogClient, _super);
+
+  function PostHogClient(apiKey, options) {
     if (options === void 0) {
       options = {};
     }
@@ -1165,91 +1845,103 @@ function (_super) {
     options.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'json';
     options.preloadFeatureFlags = false; // Don't preload as this makes no sense without a distinctId
 
+    options.sendFeatureFlagEvent = false; // Let `posthog-node` handle this on its own, since we're dealing with multiple distinctIDs
+
     _this = _super.call(this, apiKey, options) || this;
+    _this.options = options;
     _this._memoryStorage = new PostHogMemoryStorage();
     return _this;
   }
 
-  PostHog.prototype.getPersistedProperty = function (key) {
+  PostHogClient.prototype.getPersistedProperty = function (key) {
     return this._memoryStorage.getProperty(key);
   };
 
-  PostHog.prototype.setPersistedProperty = function (key, value) {
+  PostHogClient.prototype.setPersistedProperty = function (key, value) {
     return this._memoryStorage.setProperty(key, value);
   };
 
-  PostHog.prototype.getSessionId = function () {
+  PostHogClient.prototype.getSessionId = function () {
     // Sessions don't make sense for Node
     return undefined;
   };
 
-  PostHog.prototype.fetch = function (url, options) {
-    return undici.fetch(url, options);
+  PostHogClient.prototype.fetch = function (url, options) {
+    return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
   };
 
-  PostHog.prototype.getLibraryId = function () {
+  PostHogClient.prototype.getLibraryId = function () {
     return 'posthog-node';
   };
 
-  PostHog.prototype.getLibraryVersion = function () {
+  PostHogClient.prototype.getLibraryVersion = function () {
     return version;
   };
 
-  PostHog.prototype.getCustomUserAgent = function () {
+  PostHogClient.prototype.getCustomUserAgent = function () {
     return "posthog-node/".concat(version);
   };
 
-  return PostHog;
+  return PostHogClient;
 }(PostHogCore); // The actual exported Nodejs API.
 
 
-var PostHogGlobal =
+var PostHog =
 /** @class */
 function () {
-  function PostHogGlobal(apiKey, options) {
+  function PostHog(apiKey, options) {
     if (options === void 0) {
       options = {};
     }
 
-    this._sharedClient = new PostHog(apiKey, options);
-  }
-
-  PostHogGlobal.prototype.reInit = function (distinctId) {
-    // Certain properties we want to persist
-    var propertiesToKeep = [PostHogPersistedProperty.Queue, PostHogPersistedProperty.OptedOut];
+    this._sharedClient = new PostHogClient(apiKey, options);
 
-    for (var key in PostHogPersistedProperty) {
-      if (!propertiesToKeep.includes(key)) {
-        this._sharedClient.setPersistedProperty(PostHogPersistedProperty[key], null);
-      }
+    if (options.personalApiKey) {
+      this.featureFlagsPoller = new FeatureFlagsPoller({
+        pollingInterval: typeof options.featureFlagsPollingInterval === 'number' ? options.featureFlagsPollingInterval : THIRTY_SECONDS,
+        personalApiKey: options.personalApiKey,
+        projectApiKey: apiKey,
+        timeout: options.requestTimeout,
+        host: this._sharedClient.host,
+        fetch: options.fetch
+      });
     }
 
+    this.distinctIdHasSentFlagCalls = {};
+    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
+  }
+
+  PostHog.prototype.reInit = function (distinctId) {
+    // Certain properties we want to persist. Queue is persisted always by default.
+    this._sharedClient.reset([PostHogPersistedProperty.OptedOut]);
+
     this._sharedClient.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
   };
 
-  PostHogGlobal.prototype.enable = function () {
+  PostHog.prototype.enable = function () {
     return this._sharedClient.optIn();
   };
 
-  PostHogGlobal.prototype.disable = function () {
+  PostHog.prototype.disable = function () {
     return this._sharedClient.optOut();
   };
 
-  PostHogGlobal.prototype.capture = function (_a) {
+  PostHog.prototype.capture = function (_a) {
     var distinctId = _a.distinctId,
         event = _a.event,
         properties = _a.properties,
-        groups = _a.groups;
+        groups = _a.groups,
+        sendFeatureFlags = _a.sendFeatureFlags;
     this.reInit(distinctId);
 
     if (groups) {
       this._sharedClient.groups(groups);
     }
 
-    this._sharedClient.capture(event, properties);
+    this._sharedClient.capture(event, properties, sendFeatureFlags || false);
   };
 
-  PostHogGlobal.prototype.identify = function (_a) {
+  PostHog.prototype.identify = function (_a) {
     var distinctId = _a.distinctId,
         properties = _a.properties;
     this.reInit(distinctId);
@@ -1257,39 +1949,101 @@ function () {
     this._sharedClient.identify(distinctId, properties);
   };
 
-  PostHogGlobal.prototype.alias = function (data) {
+  PostHog.prototype.alias = function (data) {
     this.reInit(data.distinctId);
 
     this._sharedClient.alias(data.alias);
   };
 
-  PostHogGlobal.prototype.getFeatureFlag = function (key, distinctId, groups) {
+  PostHog.prototype.getFeatureFlag = function (key, distinctId, options) {
+    var _a;
+
     return __awaiter(this, void 0, void 0, function () {
-      return __generator(this, function (_a) {
-        switch (_a.label) {
+      var _b, groups, personProperties, groupProperties, _c, onlyEvaluateLocally, sendFeatureFlagEvents, response, flagWasLocallyEvaluated, featureFlagReportedKey;
+
+      return __generator(this, function (_d) {
+        switch (_d.label) {
           case 0:
+            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties;
+            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, sendFeatureFlagEvents = _c.sendFeatureFlagEvents; // set defaults
+
+            if (onlyEvaluateLocally == undefined) {
+              onlyEvaluateLocally = false;
+            }
+
+            if (sendFeatureFlagEvents == undefined) {
+              sendFeatureFlagEvents = true;
+            }
+
+            return [4
+            /*yield*/
+            , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties)];
+
+          case 1:
+            response = _d.sent();
+            flagWasLocallyEvaluated = response !== undefined;
+            if (!(!flagWasLocallyEvaluated && !onlyEvaluateLocally)) return [3
+            /*break*/
+            , 3];
             this.reInit(distinctId);
 
-            if (groups) {
+            if (groups != undefined) {
               this._sharedClient.groups(groups);
             }
 
+            if (personProperties) {
+              this._sharedClient.personProperties(personProperties);
+            }
+
+            if (groupProperties) {
+              this._sharedClient.groupProperties(groupProperties);
+            }
+
             return [4
             /*yield*/
-            , this._sharedClient.reloadFeatureFlagsAsync()];
+            , this._sharedClient.reloadFeatureFlagsAsync(false)];
 
-          case 1:
-            _a.sent();
+          case 2:
+            _d.sent();
+
+            response = this._sharedClient.getFeatureFlag(key);
+            _d.label = 3;
+
+          case 3:
+            featureFlagReportedKey = "".concat(key, "_").concat(response);
+
+            if (sendFeatureFlagEvents && (!(distinctId in this.distinctIdHasSentFlagCalls) || !this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey))) {
+              if (Object.keys(this.distinctIdHasSentFlagCalls).length >= this.maxCacheSize) {
+                this.distinctIdHasSentFlagCalls = {};
+              }
+
+              if (Array.isArray(this.distinctIdHasSentFlagCalls[distinctId])) {
+                this.distinctIdHasSentFlagCalls[distinctId].push(featureFlagReportedKey);
+              } else {
+                this.distinctIdHasSentFlagCalls[distinctId] = [featureFlagReportedKey];
+              }
+
+              this.capture({
+                distinctId: distinctId,
+                event: '$feature_flag_called',
+                properties: {
+                  $feature_flag: key,
+                  $feature_flag_response: response,
+                  locally_evaluated: flagWasLocallyEvaluated
+                },
+                groups: groups
+              });
+            }
 
             return [2
             /*return*/
-            , this._sharedClient.getFeatureFlag(key)];
+            , response];
         }
       });
     });
   };
 
-  PostHogGlobal.prototype.isFeatureEnabled = function (key, distinctId, defaultResult, groups) {
+  PostHog.prototype.isFeatureEnabled = function (key, distinctId, options) {
     return __awaiter(this, void 0, void 0, function () {
       var feat;
       return __generator(this, function (_a) {
@@ -1297,19 +2051,94 @@ function () {
           case 0:
             return [4
             /*yield*/
-            , this.getFeatureFlag(key, distinctId, groups)];
+            , this.getFeatureFlag(key, distinctId, options)];
 
           case 1:
             feat = _a.sent();
+
+            if (feat === undefined) {
+              return [2
+              /*return*/
+              , undefined];
+            }
+
             return [2
             /*return*/
-            , !!feat || defaultResult || false];
+            , !!feat || false];
         }
       });
     });
   };
 
-  PostHogGlobal.prototype.groupIdentify = function (_a) {
+  PostHog.prototype.getAllFlags = function (distinctId, options) {
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function () {
+      var _b, groups, personProperties, groupProperties, onlyEvaluateLocally, localEvaluationResult, response, fallbackToDecide, remoteEvaluationResult;
+
+      return __generator(this, function (_c) {
+        switch (_c.label) {
+          case 0:
+            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties;
+            onlyEvaluateLocally = (options || {}).onlyEvaluateLocally; // set defaults
+
+            if (onlyEvaluateLocally == undefined) {
+              onlyEvaluateLocally = false;
+            }
+
+            return [4
+            /*yield*/
+            , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.getAllFlags(distinctId, groups, personProperties, groupProperties)];
+
+          case 1:
+            localEvaluationResult = _c.sent();
+            response = {};
+            fallbackToDecide = true;
+
+            if (localEvaluationResult) {
+              response = localEvaluationResult.response;
+              fallbackToDecide = localEvaluationResult.fallbackToDecide;
+            }
+
+            if (!(fallbackToDecide && !onlyEvaluateLocally)) return [3
+            /*break*/
+            , 3];
+            this.reInit(distinctId);
+
+            if (groups) {
+              this._sharedClient.groups(groups);
+            }
+
+            if (personProperties) {
+              this._sharedClient.personProperties(personProperties);
+            }
+
+            if (groupProperties) {
+              this._sharedClient.groupProperties(groupProperties);
+            }
+
+            return [4
+            /*yield*/
+            , this._sharedClient.reloadFeatureFlagsAsync(false)];
+
+          case 2:
+            _c.sent();
+
+            remoteEvaluationResult = this._sharedClient.getFeatureFlags();
+            return [2
+            /*return*/
+            , __assign(__assign({}, response), remoteEvaluationResult)];
+
+          case 3:
+            return [2
+            /*return*/
+            , response];
+        }
+      });
+    });
+  };
+
+  PostHog.prototype.groupIdentify = function (_a) {
     var groupType = _a.groupType,
         groupKey = _a.groupKey,
         properties = _a.properties;
@@ -1317,24 +2146,55 @@ function () {
     this._sharedClient.groupIdentify(groupType, groupKey, properties);
   };
 
-  PostHogGlobal.prototype.reloadFeatureFlags = function () {
-    throw new Error('Method not implemented.');
+  PostHog.prototype.reloadFeatureFlags = function () {
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.loadFeatureFlags(true)];
+
+          case 1:
+            _b.sent();
+
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
   };
 
-  PostHogGlobal.prototype.shutdown = function () {
-    void this._sharedClient.shutdownAsync();
+  PostHog.prototype.flush = function () {
+    this._sharedClient.flush();
   };
 
-  PostHogGlobal.prototype.shutdownAsync = function () {
-    return this._sharedClient.shutdownAsync();
+  PostHog.prototype.shutdown = function () {
+    void this.shutdownAsync();
   };
 
-  PostHogGlobal.prototype.debug = function (enabled) {
+  PostHog.prototype.shutdownAsync = function () {
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_b) {
+        (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.stopPoller();
+        return [2
+        /*return*/
+        , this._sharedClient.shutdownAsync()];
+      });
+    });
+  };
+
+  PostHog.prototype.debug = function (enabled) {
     return this._sharedClient.debug(enabled);
   };
 
-  return PostHogGlobal;
+  return PostHog;
 }();
 
-export { PostHogGlobal, PostHogGlobal as default };
+export { PostHog };
 //# sourceMappingURL=index.esm.js.map