posthog-node 4.3.1 → 4.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Next
 
+# 4.4.0 - 2025-01-15
+
+Switch from rusha to native (node:crypto) sha1 implementation
+
+# 4.3.2 - 2024-12-11
+
+1. REVERT: Fix bug where this SDK incorrectly sent `$feature_flag_called` events with null values when using `getFeatureFlagPayload`.
+
 # 4.3.1 - 2024-11-26
 
 1. Fix bug where this SDK incorrectly sent `$feature_flag_called` events with null values when using `getFeatureFlagPayload`.

package/README.md

@@ -2,7 +2,7 @@
 
 Please see the main [PostHog docs](https://www.posthog.com/docs).
 
-Specifically, the [Node.js integration](https://posthog.com/docs/integrate/server/node) details.
+Specifically, the [Node.js docs](https://posthog.com/docs/libraries/node) details.
 
 ## Questions?
 

package/benchmarks/rusha-vs-native.mjs

@@ -0,0 +1,70 @@
+// @ts-check
+
+import { bench, run, summary } from "mitata";
+import { createHash } from "node:crypto"
+import pkg from 'rusha';
+const { createHash: createHashRusha } = pkg;
+
+// eslint-disable-next-line
+const LONG_SCALE = 0xfffffffffffffff
+
+// from https://github.com/PostHog/posthog-js-lite/blob/2baa794708d78d5d10940817c3768e47abe2da99/posthog-node/src/feature-flags.ts#L460-L465
+function _hashRusha(key, distinctId, salt = '') {
+    // rusha is a fast sha1 implementation in pure javascript
+    const sha1Hash = createHashRusha()
+    sha1Hash.update(`${key}.${distinctId}${salt}`)
+    return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE
+}
+
+function _hash(key, distinctId, salt = '') {
+    const sha1Hash = createHash("sha1")
+    sha1Hash.update(`${key}.${distinctId}${salt}`)
+    return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE
+}
+
+summary(() => {
+	bench("_hash with rusha", () => {
+		_hashRusha("test", "user_id")
+	});
+
+	bench("_hash with native", () => {
+		_hash("test", "user_id")
+	});
+});
+
+await run();
+
+
+// !NODE
+// node benchmarks/rusha-vs-native.mjs
+// clk: ~3.99 GHz
+// cpu: AMD Ryzen 7 7700 8-Core Processor
+// runtime: node 22.11.0 (x64-linux)
+
+// benchmark                   avg (min … max) p75   p99    (min … top 1%)
+// ------------------------------------------- -------------------------------
+// _hash with rusha              12.10 µs/iter   7.25 µs █
+//                         (4.66 µs … 1.27 ms) 116.62 µs █▄▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+// _hash with native            547.04 ns/iter 435.45 ns █
+//                       (370.08 ns … 3.61 µs)   3.58 µs █▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+
+// summary
+//   _hash with native
+//    22.12x faster than _hash with rusha
+
+// !BUN
+// bun benchmarks/rusha-vs-native.mjs 
+// clk: ~5.04 GHz
+// cpu: AMD Ryzen 7 7700 8-Core Processor
+// runtime: bun 1.1.37 (x64-linux)
+
+// benchmark                   avg (min … max) p75   p99    (min … top 1%)
+// ------------------------------------------- -------------------------------
+// _hash with rusha              10.00 µs/iter   4.96 µs  █
+//                         (2.60 µs … 2.78 ms)  45.85 µs ▂█▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+// _hash with native            471.82 ns/iter 420.00 ns █
+//                     (370.00 ns … 949.79 µs)   1.99 µs █▆▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+
+// summary
+//   _hash with native
+//    21.19x faster than _hash with rusha

package/lib/index.cjs.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var rusha = require('rusha');
+var node_crypto = require('node:crypto');
 
-var version = "4.3.1";
+var version = "4.4.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -13,6 +13,8 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["Props"] = "props";
     PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
     PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
+    PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
+    PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
     PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
     PostHogPersistedProperty["Queue"] = "queue";
     PostHogPersistedProperty["OptedOut"] = "opted_out";
@@ -23,6 +25,7 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
+    PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 
 function assert(truthyValue, message) {
@@ -1786,8 +1789,7 @@ class FeatureFlagsPoller {
 // # 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 = '') {
-  // rusha is a fast sha1 implementation in pure javascript
-  const sha1Hash = rusha.createHash();
+  const sha1Hash = node_crypto.createHash('sha1');
   sha1Hash.update(`${key}.${distinctId}${salt}`);
   return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE;
 }
@@ -2234,70 +2236,44 @@ class PostHog extends PostHogCoreStateless {
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     const {
       groups,
-      disableGeoip,
-      onlyEvaluateLocally = false,
+      disableGeoip
+    } = options || {};
+    let {
+      onlyEvaluateLocally,
+      sendFeatureFlagEvents,
       personProperties,
       groupProperties
     } = options || {};
-    const {
-      allPersonProperties,
-      allGroupProperties
-    } = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    if (matchValue === undefined) {
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    personProperties = adjustedProperties.allPersonProperties;
+    groupProperties = adjustedProperties.allGroupProperties;
+    let response = undefined;
+    // Try to get match value locally if not provided
+    if (!matchValue) {
       matchValue = await this.getFeatureFlag(key, distinctId, {
         ...options,
-        onlyEvaluateLocally: true,
-        sendFeatureFlagEvents: false
+        onlyEvaluateLocally: true
       });
     }
-    let response;
-    let payload;
     if (matchValue) {
-      response = matchValue;
-      payload = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
-    } else {
-      response = undefined;
-      payload = undefined;
+      response = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
     }
-    // Determine if the payload was evaluated locally
-    const payloadWasLocallyEvaluated = payload !== undefined;
-    // Fetch final flags and payloads either locally or from the remote server
-    let fetchedOrLocalFlags;
-    let fetchedOrLocalPayloads;
-    if (payloadWasLocallyEvaluated || onlyEvaluateLocally) {
-      if (response !== undefined) {
-        fetchedOrLocalFlags = {
-          [key]: response
-        };
-        fetchedOrLocalPayloads = {
-          [key]: payload
-        };
-      } else {
-        fetchedOrLocalFlags = {};
-        fetchedOrLocalPayloads = {};
-      }
-    } else {
-      const fetchedData = await super.getFeatureFlagsAndPayloadsStateless(distinctId, groups, allPersonProperties, allGroupProperties, disableGeoip);
-      fetchedOrLocalFlags = fetchedData.flags || {};
-      fetchedOrLocalPayloads = fetchedData.payloads || {};
+    // set defaults
+    if (onlyEvaluateLocally == undefined) {
+      onlyEvaluateLocally = false;
     }
-    const finalResponse = fetchedOrLocalFlags[key];
-    const finalPayload = fetchedOrLocalPayloads[key];
-    const finalLocallyEvaluated = payloadWasLocallyEvaluated;
-    this.capture({
-      distinctId,
-      event: '$feature_flag_called',
-      properties: {
-        $feature_flag: key,
-        $feature_flag_response: finalResponse,
-        $feature_flag_payload: finalPayload,
-        locally_evaluated: finalLocallyEvaluated,
-        [`$feature/${key}`]: finalResponse
-      },
-      groups,
-      disableGeoip
-    });
-    return finalPayload;
+    if (sendFeatureFlagEvents == undefined) {
+      sendFeatureFlagEvents = true;
+    }
+    // set defaults
+    if (onlyEvaluateLocally == undefined) {
+      onlyEvaluateLocally = false;
+    }
+    const payloadWasLocallyEvaluated = response !== undefined;
+    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
+      response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+    }
+    return response;
   }
   async isFeatureEnabled(key, distinctId, options) {
     const feat = await this.getFeatureFlag(key, distinctId, options);