posthog-node 3.2.1 → 3.4.0

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 3.4.0 - 2024-01-09
+
+1. Numeric property handling for feature flags now does the expected: When passed in a number, we do a numeric comparison. When passed in a string, we do a string comparison. Previously, we always did a string comparison.
+2. Add support for relative date operators for local evaluation.
+
+# 3.3.0 - 2024-01-02
+
+1. Adds PostHogSentryIntegration to allow automatic capturing of exceptions reported via the @sentry/node package
+
 # 3.2.1 - 2023-12-15
 
 1. Fixes issue where a background refresh of feature flags could throw an unhandled error. It now emits to be detected by `.on('error', ...)`

package/index.ts

@@ -1 +1,2 @@
 export * from './src/posthog-node'
+export * from './src/extensions/sentry-integration'

package/lib/index.cjs.js

@@ -158,7 +158,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "3.2.1";
+var version = "3.4.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -2348,12 +2348,36 @@ function matchProperty(property, propertyValues) {
 
   var overrideValue = propertyValues[key];
 
+  function computeExactMatch(value, overrideValue) {
+    if (Array.isArray(value)) {
+      return value.map(function (val) {
+        return String(val).toLowerCase();
+      }).includes(String(overrideValue).toLowerCase());
+    }
+
+    return String(value).toLowerCase() === String(overrideValue).toLowerCase();
+  }
+
+  function compare(lhs, rhs, operator) {
+    if (operator === 'gt') {
+      return lhs > rhs;
+    } else if (operator === 'gte') {
+      return lhs >= rhs;
+    } else if (operator === 'lt') {
+      return lhs < rhs;
+    } else if (operator === 'lte') {
+      return lhs <= rhs;
+    } else {
+      throw new Error("Invalid operator: ".concat(operator));
+    }
+  }
+
   switch (operator) {
     case 'exact':
-      return Array.isArray(value) ? value.indexOf(overrideValue) !== -1 : value === overrideValue;
+      return computeExactMatch(value, overrideValue);
 
     case 'is_not':
-      return Array.isArray(value) ? value.indexOf(overrideValue) === -1 : value !== overrideValue;
+      return !computeExactMatch(value, overrideValue);
 
     case 'is_set':
       return key in propertyValues;
@@ -2371,24 +2395,53 @@ function matchProperty(property, propertyValues) {
       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;
+      {
+        // :TRICKY: We adjust comparison based on the override value passed in,
+        // to make sure we handle both numeric and string comparisons appropriately.
+        var parsedValue = typeof value === 'number' ? value : null;
+
+        if (typeof value === 'string') {
+          try {
+            parsedValue = parseFloat(value);
+          } catch (err) {// pass
+          }
+        }
+
+        if (parsedValue != null && overrideValue != null) {
+          // check both null and undefined
+          if (typeof overrideValue === 'string') {
+            return compare(overrideValue, String(value), operator);
+          } else {
+            return compare(overrideValue, parsedValue, operator);
+          }
+        } else {
+          return compare(String(overrideValue), String(value), operator);
+        }
+      }
 
     case 'is_date_after':
     case 'is_date_before':
+    case 'is_relative_date_before':
+    case 'is_relative_date_after':
       {
-        var parsedDate = convertToDateTime(value);
+        var parsedDate = null;
+
+        if (['is_relative_date_before', 'is_relative_date_after'].includes(operator)) {
+          parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+        } else {
+          parsedDate = convertToDateTime(value);
+        }
+
+        if (parsedDate == null) {
+          throw new InconclusiveMatchError("Invalid date: ".concat(value));
+        }
+
         var overrideDate = convertToDateTime(overrideValue);
 
-        if (operator === 'is_date_before') {
+        if (['is_date_before', 'is_relative_date_before'].includes(operator)) {
           return overrideDate < parsedDate;
         }
 
@@ -2396,8 +2449,7 @@ function matchProperty(property, propertyValues) {
       }
 
     default:
-      console.error("Unknown operator: ".concat(operator));
-      return false;
+      throw new InconclusiveMatchError("Unknown operator: ".concat(operator));
   }
 }
 
@@ -2539,6 +2591,45 @@ function convertToDateTime(value) {
   }
 }
 
+function relativeDateParseForFeatureFlagMatching(value) {
+  var regex = /^(?<number>[0-9]+)(?<interval>[a-z])$/;
+  var match = value.match(regex);
+  var parsedDt = new Date(new Date().toISOString());
+
+  if (match) {
+    if (!match.groups) {
+      return null;
+    }
+
+    var number = parseInt(match.groups['number']);
+
+    if (number >= 10000) {
+      // Guard against overflow, disallow numbers greater than 10_000
+      return null;
+    }
+
+    var interval = match.groups['interval'];
+
+    if (interval == 'h') {
+      parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+    } else if (interval == 'd') {
+      parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+    } else if (interval == 'w') {
+      parsedDt.setUTCDate(parsedDt.getUTCDate() - number * 7);
+    } else if (interval == 'm') {
+      parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+    } else if (interval == 'y') {
+      parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+    } else {
+      return null;
+    }
+
+    return parsedDt;
+  } else {
+    return null;
+  }
+}
+
 var THIRTY_SECONDS = 30 * 1000;
 var MAX_CACHE_SIZE = 50 * 1000; // The actual exported Nodejs API.
 
@@ -3009,5 +3100,95 @@ function (_super) {
   return PostHog;
 }(PostHogCoreStateless);
 
+/**
+ * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
+ *
+ * ### Usage
+ *
+ *     Sentry.init({
+ *          dsn: 'https://example',
+ *          integrations: [
+ *              new PostHogSentryIntegration(posthog)
+ *          ]
+ *     })
+ *
+ *     Sentry.setTag(PostHogSentryIntegration.POSTHOG_ID_TAG, 'some distinct id');
+ *
+ * @param {Object} [posthog] The posthog object
+ * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry
+ * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry
+ * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
+ */
+var PostHogSentryIntegration =
+/** @class */
+function () {
+  function PostHogSentryIntegration(posthog, posthogHost, organization, prefix) {
+    var _a;
+
+    this.posthog = posthog;
+    this.posthogHost = posthogHost;
+    this.organization = organization;
+    this.prefix = prefix;
+    this.name = 'posthog-node';
+    this.posthogHost = (_a = posthog.options.host) !== null && _a !== void 0 ? _a : 'https://app.posthog.com';
+  }
+
+  PostHogSentryIntegration.prototype.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {
+    var _this = this;
+
+    addGlobalEventProcessor(function (event) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+
+      if (((_a = event.exception) === null || _a === void 0 ? void 0 : _a.values) === undefined || event.exception.values.length === 0) {
+        return event;
+      }
+
+      if (!event.tags) {
+        event.tags = {};
+      }
+
+      var sentry = getCurrentHub(); // Get the PostHog user ID from a specific tag, which users can set on their Sentry scope as they need.
+
+      var userId = event.tags[PostHogSentryIntegration.POSTHOG_ID_TAG];
+
+      if (userId === undefined) {
+        // If we can't find a user ID, don't bother linking the event. We won't be able to send anything meaningful to PostHog without it.
+        return event;
+      }
+
+      event.tags['PostHog Person URL'] = new URL("/person/".concat(userId), _this.posthogHost).toString();
+      var properties = {
+        // PostHog Exception Properties
+        $exception_message: (_b = event.exception.values[0]) === null || _b === void 0 ? void 0 : _b.value,
+        $exception_type: (_c = event.exception.values[0]) === null || _c === void 0 ? void 0 : _c.type,
+        $exception_personURL: event.tags['PostHog Person URL'],
+        // Sentry Exception Properties
+        $sentry_event_id: event.event_id,
+        $sentry_exception: event.exception,
+        $sentry_exception_message: (_d = event.exception.values[0]) === null || _d === void 0 ? void 0 : _d.value,
+        $sentry_exception_type: (_e = event.exception.values[0]) === null || _e === void 0 ? void 0 : _e.type,
+        $sentry_tags: event.tags
+      };
+      var projectId = (_g = (_f = sentry.getClient()) === null || _f === void 0 ? void 0 : _f.getDsn()) === null || _g === void 0 ? void 0 : _g.projectId;
+
+      if (_this.organization !== undefined && projectId !== undefined && event.event_id !== undefined) {
+        properties.$sentry_url = "".concat((_h = _this.prefix) !== null && _h !== void 0 ? _h : 'https://sentry.io/organizations', "/").concat(_this.organization, "/issues/?project=").concat(projectId, "&query=").concat(event.event_id);
+      }
+
+      _this.posthog.capture({
+        event: '$exception',
+        distinctId: userId,
+        properties: properties
+      });
+
+      return event;
+    });
+  };
+
+  PostHogSentryIntegration.POSTHOG_ID_TAG = 'posthog_distinct_id';
+  return PostHogSentryIntegration;
+}();
+
 exports.PostHog = PostHog;
+exports.PostHogSentryIntegration = PostHogSentryIntegration;
 //# sourceMappingURL=index.cjs.js.map