@rpcbase/server 0.507.0 → 0.508.0

package/dist/index.js

@@ -539,6 +539,8 @@ var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedP
   PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
   PostHogPersistedProperty["DistinctId"] = "distinct_id";
   PostHogPersistedProperty["Props"] = "props";
+  PostHogPersistedProperty["EnablePersonProcessing"] = "enable_person_processing";
+  PostHogPersistedProperty["PersonMode"] = "person_mode";
   PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
   PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
   PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
@@ -573,7 +575,7 @@ const isObject = (x) => x === Object(x) && !isArray(x);
 const isUndefined = (x) => void 0 === x;
 const isString = (x) => "[object String]" == type_utils_toString.call(x);
 const isEmptyString = (x) => isString(x) && 0 === x.trim().length;
-const isNumber = (x) => "[object Number]" == type_utils_toString.call(x);
+const isNumber = (x) => "[object Number]" == type_utils_toString.call(x) && x === x;
 const isPlainError = (x) => x instanceof Error;
 function isPrimitive(value) {
   return null === value || "object" != typeof value;
@@ -855,10 +857,11 @@ class PostHogCoreStateless {
     this.disableGeoip = options.disableGeoip ?? true;
     this.disabled = options.disabled ?? false;
     this.historicalMigration = options?.historicalMigration ?? false;
-    this.evaluationEnvironments = options?.evaluationEnvironments;
     this._initPromise = Promise.resolve();
     this._isInitialized = true;
     this._logger = createLogger("[PostHog]", this.logMsgIfDebug.bind(this));
+    this.evaluationContexts = options?.evaluationContexts ?? options?.evaluationEnvironments;
+    if (options?.evaluationEnvironments && !options?.evaluationContexts) this._logger.warn("evaluationEnvironments is deprecated. Use evaluationContexts instead. This property will be removed in a future version.");
     this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
   }
   logMsgIfDebug(fn) {
@@ -1033,7 +1036,7 @@ class PostHogCoreStateless {
       group_properties: groupProperties,
       ...extraPayload
     };
-    if (this.evaluationEnvironments && this.evaluationEnvironments.length > 0) requestData.evaluation_environments = this.evaluationEnvironments;
+    if (this.evaluationContexts && this.evaluationContexts.length > 0) requestData.evaluation_contexts = this.evaluationContexts;
     const fetchOptions = {
       method: "POST",
       headers: {
@@ -1045,10 +1048,35 @@ class PostHogCoreStateless {
     this._logger.info("Flags URL", url);
     return this.fetchWithRetry(url, fetchOptions, {
       retryCount: 0
-    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => normalizeFlagsResponse(response)).catch((error) => {
+    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => ({
+      success: true,
+      response: normalizeFlagsResponse(response)
+    })).catch((error) => {
       this._events.emit("error", error);
+      return {
+        success: false,
+        error: this.categorizeRequestError(error)
+      };
     });
   }
+  categorizeRequestError(error) {
+    if (error instanceof PostHogFetchHttpError) return {
+      type: "api_error",
+      statusCode: error.status
+    };
+    if (error instanceof PostHogFetchNetworkError) {
+      const cause = error.error;
+      if (cause instanceof Error && ("AbortError" === cause.name || "TimeoutError" === cause.name)) return {
+        type: "timeout"
+      };
+      return {
+        type: "connection_error"
+      };
+    }
+    return {
+      type: "unknown_error"
+    };
+  }
   async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
     await this._initPromise;
     const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
@@ -1115,8 +1143,9 @@ class PostHogCoreStateless {
     const extraPayload = {};
     if (disableGeoip ?? this.disableGeoip) extraPayload["geoip_disable"] = true;
     if (flagKeysToEvaluate) extraPayload["flag_keys_to_evaluate"] = flagKeysToEvaluate;
-    const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
-    if (void 0 === flagsResponse) return;
+    const result = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+    if (!result.success) return;
+    const flagsResponse = result.response;
     if (flagsResponse.errorsWhileComputingFlags) console.error("[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices");
     if (flagsResponse.quotaLimited?.includes("feature_flags")) {
       console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
@@ -1183,10 +1212,17 @@ class PostHogCoreStateless {
       this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
     });
   }
+  processBeforeEnqueue(message) {
+    return message;
+  }
+  async flushStorage() {
+  }
   enqueue(type, _message, options) {
     this.wrap(() => {
       if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
-      const message = this.prepareMessage(type, _message, options);
+      let message = this.prepareMessage(type, _message, options);
+      message = this.processBeforeEnqueue(message);
+      if (null === message) return;
       const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
       if (queue.length >= this.maxQueueSize) {
         queue.shift();
@@ -1205,10 +1241,13 @@ class PostHogCoreStateless {
     if (this.disabled) return void this._logger.warn("The client is disabled");
     if (!this._isInitialized) await this._initPromise;
     if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
+    let message = this.prepareMessage(type, _message, options);
+    message = this.processBeforeEnqueue(message);
+    if (null === message) return;
     const data = {
       api_key: this.apiKey,
       batch: [
-        this.prepareMessage(type, _message, options)
+        message
       ],
       sent_at: currentISOTime()
     };
@@ -1293,11 +1332,12 @@ class PostHogCoreStateless {
     while (queue.length > 0 && sentMessages.length < originalQueueLength) {
       const batchItems = queue.slice(0, this.maxBatchSize);
       const batchMessages = batchItems.map((item) => item.message);
-      const persistQueueChange = () => {
+      const persistQueueChange = async () => {
         const refreshedQueue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
         const newQueue = refreshedQueue.slice(batchItems.length);
         this.setPersistedProperty(types_PostHogPersistedProperty.Queue, newQueue);
         queue = newQueue;
+        await this.flushStorage();
       };
       const data = {
         api_key: this.apiKey,
@@ -1333,11 +1373,11 @@ class PostHogCoreStateless {
           this._logger.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`);
           continue;
         }
-        if (!(err instanceof PostHogFetchNetworkError)) persistQueueChange();
+        if (!(err instanceof PostHogFetchNetworkError)) await persistQueueChange();
         this._events.emit("error", err);
         throw err;
       }
-      persistQueueChange();
+      await persistQueueChange();
       sentMessages.push(...batchMessages);
     }
     this._events.emit("flush", sentMessages);
@@ -1462,7 +1502,7 @@ class ErrorPropertiesBuilder {
     };
     const coercingContext = this.buildCoercingContext(mechanism, hint, 0);
     const exceptionWithCause = coercingContext.apply(input);
-    const parsingContext = this.buildParsingContext();
+    const parsingContext = this.buildParsingContext(hint);
     const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext);
     const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism);
     return {
@@ -1486,7 +1526,7 @@ class ErrorPropertiesBuilder {
     let cause;
     if (null != err.cause) cause = this.parseStacktrace(err.cause, ctx);
     let stack;
-    if ("" != err.stack && null != err.stack) stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? 1 : 0), ctx.chunkIdMap);
+    if ("" != err.stack && null != err.stack) stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? ctx.skipFirstLines : 0), ctx.chunkIdMap);
     return {
       ...err,
       cause,
@@ -1531,9 +1571,10 @@ class ErrorPropertiesBuilder {
     }));
     return exceptionList;
   }
-  buildParsingContext() {
+  buildParsingContext(hint) {
     const context = {
-      chunkIdMap: getFilenameToChunkIdMap(this.stackParser)
+      chunkIdMap: getFilenameToChunkIdMap(this.stackParser),
+      skipFirstLines: hint.skipFirstLines ?? 1
     };
     return context;
   }
@@ -2105,7 +2146,7 @@ class ErrorTracking {
     this._rateLimiter.stop();
   }
 }
-const version = "5.20.0";
+const version = "5.24.11";
 const FeatureFlagError = {
   ERRORS_WHILE_COMPUTING: "errors_while_computing_flags",
   FLAG_MISSING: "flag_missing",
@@ -2170,6 +2211,7 @@ class FeatureFlagsPoller {
     this.customHeaders = customHeaders;
     this.onLoad = options.onLoad;
     this.cacheProvider = options.cacheProvider;
+    this.strictLocalEvaluation = options.strictLocalEvaluation ?? false;
     this.loadFeatureFlags();
   }
   debug(enabled = true) {
@@ -2365,6 +2407,11 @@ class FeatureFlagsPoller {
     this.cohorts = flagData.cohorts;
     this.loadedSuccessfullyOnce = true;
   }
+  warnAboutExperienceContinuityFlags(flags) {
+    if (this.strictLocalEvaluation) return;
+    const experienceContinuityFlags = flags.filter((f) => f.ensure_experience_continuity);
+    if (experienceContinuityFlags.length > 0) console.warn(`[PostHog] You are using local evaluation but ${experienceContinuityFlags.length} flag(s) have experience continuity enabled: ${experienceContinuityFlags.map((f) => f.key).join(", ")}. Experience continuity is incompatible with local evaluation and will cause a server request on every flag evaluation, negating local evaluation cost savings. To avoid server requests and unexpected costs, either disable experience continuity on these flags in PostHog, use strictLocalEvaluation: true in client init, or pass onlyEvaluateLocally: true per flag call (flags that cannot be evaluated locally will return undefined).`);
+  }
   async loadFromCache(debugMessage) {
     if (!this.cacheProvider) return false;
     try {
@@ -2373,6 +2420,7 @@ class FeatureFlagsPoller {
         this.updateFlagState(cached);
         this.logMsgIfDebug(() => console.debug(`[FEATURE FLAGS] ${debugMessage} (${cached.flags.length} flags)`));
         this.onLoad?.(this.featureFlags.length);
+        this.warnAboutExperienceContinuityFlags(cached.flags);
         return true;
       }
       return false;
@@ -2466,6 +2514,7 @@ class FeatureFlagsPoller {
             this.onError?.(new Error(`Failed to store in cache: ${err}`));
           }
           this.onLoad?.(this.featureFlags.length);
+          this.warnAboutExperienceContinuityFlags(flagData.flags);
           break;
         }
         default:
@@ -2720,7 +2769,8 @@ class PostHogBackendClient extends PostHogCoreStateless {
           this._events.emit("localEvaluationFlagsLoaded", count);
         },
         customHeaders: this.getCustomHeaders(),
-        cacheProvider: options.flagDefinitionCacheProvider
+        cacheProvider: options.flagDefinitionCacheProvider,
+        strictLocalEvaluation: options.strictLocalEvaluation
       });
     }
     this.errorTracking = new ErrorTracking(this, options, this._logger);
@@ -2826,21 +2876,56 @@ class PostHogBackendClient extends PostHogCoreStateless {
       });
     });
   }
-  async getFeatureFlag(key, distinctId, options) {
-    if (void 0 !== this._flagOverrides && key in this._flagOverrides) return this._flagOverrides[key];
-    const { groups, disableGeoip } = options || {};
-    let { onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties } = options || {};
+  async _getFeatureFlagResult(key, distinctId, options = {}, matchValue) {
+    const sendFeatureFlagEvents = options.sendFeatureFlagEvents ?? true;
+    if (void 0 !== this._flagOverrides && key in this._flagOverrides) {
+      const overrideValue = this._flagOverrides[key];
+      if (void 0 === overrideValue) return;
+      const overridePayload = this._payloadOverrides?.[key];
+      return {
+        key,
+        enabled: false !== overrideValue,
+        variant: "string" == typeof overrideValue ? overrideValue : void 0,
+        payload: overridePayload
+      };
+    }
+    const { groups, disableGeoip } = options;
+    let { onlyEvaluateLocally, personProperties, groupProperties } = options;
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
     groupProperties = adjustedProperties.allGroupProperties;
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    if (void 0 == sendFeatureFlagEvents) sendFeatureFlagEvents = this.options.sendFeatureFlagEvent ?? true;
-    let response = await this.featureFlagsPoller?.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties);
-    const flagWasLocallyEvaluated = void 0 !== response;
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
+    let result;
+    let flagWasLocallyEvaluated = false;
     let requestId;
     let evaluatedAt;
-    let flagDetail;
     let featureFlagError;
+    let flagId;
+    let flagVersion;
+    let flagReason;
+    const localEvaluationEnabled = void 0 !== this.featureFlagsPoller;
+    if (localEvaluationEnabled) {
+      await this.featureFlagsPoller?.loadFeatureFlags();
+      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
+      if (flag) try {
+        const localResult = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
+        if (localResult) {
+          flagWasLocallyEvaluated = true;
+          const value = localResult.value;
+          flagId = flag.id;
+          flagReason = "Evaluated locally";
+          result = {
+            key,
+            enabled: false !== value,
+            variant: "string" == typeof value ? value : void 0,
+            payload: localResult.payload ?? void 0
+          };
+        }
+      } catch (e) {
+        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this._logger?.info(`${e.name} when computing flag locally: ${key}: ${e.message}`);
+        else throw e;
+      }
+    }
     if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
       const flagsResponse = await super.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
         key
@@ -2852,68 +2937,87 @@ class PostHogBackendClient extends PostHogCoreStateless {
         const errors = [];
         if (flagsResponse.errorsWhileComputingFlags) errors.push(FeatureFlagError.ERRORS_WHILE_COMPUTING);
         if (flagsResponse.quotaLimited?.includes("feature_flags")) errors.push(FeatureFlagError.QUOTA_LIMITED);
-        flagDetail = flagsResponse.flags[key];
+        const flagDetail = flagsResponse.flags[key];
         if (void 0 === flagDetail) errors.push(FeatureFlagError.FLAG_MISSING);
+        else {
+          flagId = flagDetail.metadata?.id;
+          flagVersion = flagDetail.metadata?.version;
+          flagReason = flagDetail.reason?.description ?? flagDetail.reason?.code;
+          let parsedPayload;
+          if (flagDetail.metadata?.payload !== void 0) try {
+            parsedPayload = JSON.parse(flagDetail.metadata.payload);
+          } catch {
+            parsedPayload = flagDetail.metadata.payload;
+          }
+          result = {
+            key,
+            enabled: flagDetail.enabled,
+            variant: flagDetail.variant,
+            payload: parsedPayload
+          };
+        }
         if (errors.length > 0) featureFlagError = errors.join(",");
-        response = getFeatureFlagValue(flagDetail);
       }
     }
-    const featureFlagReportedKey = `${key}_${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
-      ];
-      const properties = {
-        $feature_flag: key,
-        $feature_flag_response: response,
-        $feature_flag_id: flagDetail?.metadata?.id,
-        $feature_flag_version: flagDetail?.metadata?.version,
-        $feature_flag_reason: flagDetail?.reason?.description ?? flagDetail?.reason?.code,
-        locally_evaluated: flagWasLocallyEvaluated,
-        [`$feature/${key}`]: response,
-        $feature_flag_request_id: requestId,
-        $feature_flag_evaluated_at: evaluatedAt
-      };
-      if (featureFlagError) properties.$feature_flag_error = featureFlagError;
-      this.capture({
-        distinctId,
-        event: "$feature_flag_called",
-        properties,
-        groups,
-        disableGeoip
-      });
+    if (sendFeatureFlagEvents) {
+      const response = void 0 === result ? void 0 : false === result.enabled ? false : result.variant ?? true;
+      const featureFlagReportedKey = `${key}_${response}`;
+      if (!(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
+        ];
+        const properties = {
+          $feature_flag: key,
+          $feature_flag_response: response,
+          $feature_flag_id: flagId,
+          $feature_flag_version: flagVersion,
+          $feature_flag_reason: flagReason,
+          locally_evaluated: flagWasLocallyEvaluated,
+          [`$feature/${key}`]: response,
+          $feature_flag_request_id: requestId,
+          $feature_flag_evaluated_at: evaluatedAt
+        };
+        if (featureFlagError) properties.$feature_flag_error = featureFlagError;
+        this.capture({
+          distinctId,
+          event: "$feature_flag_called",
+          properties,
+          groups,
+          disableGeoip
+        });
+      }
     }
-    return response;
+    if (void 0 !== result && void 0 !== this._payloadOverrides && key in this._payloadOverrides) result = {
+      ...result,
+      payload: this._payloadOverrides[key]
+    };
+    return result;
+  }
+  async getFeatureFlag(key, distinctId, options) {
+    const result = await this._getFeatureFlagResult(key, distinctId, {
+      ...options,
+      sendFeatureFlagEvents: options?.sendFeatureFlagEvents ?? this.options.sendFeatureFlagEvent ?? true
+    });
+    if (void 0 === result) return;
+    if (false === result.enabled) return false;
+    return result.variant ?? true;
   }
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     if (void 0 !== this._payloadOverrides && key in this._payloadOverrides) return this._payloadOverrides[key];
-    const { groups, disableGeoip } = options || {};
-    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {};
-    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties;
-    let response;
-    const localEvaluationEnabled = void 0 !== this.featureFlagsPoller;
-    if (localEvaluationEnabled) {
-      await this.featureFlagsPoller?.loadFeatureFlags();
-      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
-      if (flag) try {
-        const result = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
-        if (result) {
-          matchValue = result.value;
-          response = result.payload;
-        }
-      } catch (e) {
-        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this._logger?.info(`${e.name} when computing flag locally: ${flag.key}: ${e.message}`);
-        else throw e;
-      }
-    }
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    const payloadWasLocallyEvaluated = void 0 !== response;
-    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-    return response;
+    const result = await this._getFeatureFlagResult(key, distinctId, {
+      ...options,
+      sendFeatureFlagEvents: false
+    }, matchValue);
+    if (void 0 === result) return;
+    return result.payload ?? null;
+  }
+  async getFeatureFlagResult(key, distinctId, options) {
+    return this._getFeatureFlagResult(key, distinctId, {
+      ...options,
+      sendFeatureFlagEvents: options?.sendFeatureFlagEvents ?? this.options.sendFeatureFlagEvent ?? true
+    });
   }
   async getRemoteConfigPayload(flagKey) {
     if (!this.options.personalApiKey) throw new Error("Personal API key is required for remote config payload decryption");
@@ -2941,7 +3045,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
     personProperties = adjustedProperties.allPersonProperties;
     groupProperties = adjustedProperties.allGroupProperties;
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
+    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
     const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties, flagKeys);
     let featureFlags = {};
     let featureFlagPayloads = {};
@@ -3091,7 +3195,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
     const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
     const flagKeys = sendFeatureFlagsOptions?.flagKeys;
-    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? false;
+    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? this.options.strictLocalEvaluation ?? false;
     if (onlyEvaluateLocally) if (!((this.featureFlagsPoller?.featureFlags?.length || 0) > 0)) return {};
     else {
       const groupsWithStringValues = {};