posthog-node 3.3.0 → 3.5.0

package/lib/posthog-core/src/index.d.ts

@@ -12,9 +12,9 @@ export declare abstract class PostHogCoreStateless {
     private captureMode;
     private removeDebugCallback?;
     private debugMode;
-    private pendingPromises;
     private disableGeoip;
     private _optoutOverride;
+    private pendingPromises;
     protected _events: SimpleEventEmitter;
     protected _flushTimer?: any;
     protected _retryOptions: RetriableOptions;
@@ -32,6 +32,7 @@ export declare abstract class PostHogCoreStateless {
     on(event: string, cb: (...args: any[]) => void): () => void;
     debug(enabled?: boolean): void;
     private buildPayload;
+    protected addPendingPromise(promise: Promise<any>): void;
     /***
      *** TRACKING
      ***/

package/lib/posthog-node/src/feature-flags.d.ts

@@ -55,4 +55,5 @@ declare class FeatureFlagsPoller {
     stopPoller(): void;
 }
 declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>): boolean;
-export { FeatureFlagsPoller, matchProperty, InconclusiveMatchError, ClientError };
+declare function relativeDateParseForFeatureFlagMatching(value: string): Date | null;
+export { FeatureFlagsPoller, matchProperty, relativeDateParseForFeatureFlagMatching, InconclusiveMatchError, ClientError, };

package/lib/posthog-node/src/posthog-node.d.ts

@@ -73,4 +73,5 @@ export declare class PostHog extends PostHogCoreStateless implements PostHogNode
     reloadFeatureFlags(): Promise<void>;
     shutdown(): void;
     shutdownAsync(): Promise<void>;
+    private addLocalPersonAndGroupProperties;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-node",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "PostHog Node.js integration",
   "repository": {
     "type": "git",

package/src/feature-flags.ts

@@ -121,7 +121,7 @@ class FeatureFlagsPoller {
             console.debug(`InconclusiveMatchError when computing flag locally: ${key}: ${e}`)
           }
         } else if (e instanceof Error) {
-          console.error(`Error computing flag locally: ${key}: ${e}`)
+          this.onError?.(new Error(`Error computing flag locally: ${key}: ${e}`))
         }
       }
     }
@@ -211,14 +211,18 @@ class FeatureFlagsPoller {
       const groupName = this.groupTypeMapping[String(aggregation_group_type_index)]
 
       if (!groupName) {
-        console.warn(
-          `[FEATURE FLAGS] Unknown group type index ${aggregation_group_type_index} for feature flag ${flag.key}`
-        )
+        if (this.debugMode) {
+          console.warn(
+            `[FEATURE FLAGS] Unknown group type index ${aggregation_group_type_index} for feature flag ${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: ${flag.key} without group names passed in`)
+        if (this.debugMode) {
+          console.warn(`[FEATURE FLAGS] Can't compute group feature flag: ${flag.key} without group names passed in`)
+        }
         return false
       }
 
@@ -383,7 +387,7 @@ class FeatureFlagsPoller {
 
       const responseJson = await res.json()
       if (!('flags' in responseJson)) {
-        console.error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`)
+        this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`))
       }
 
       this.featureFlags = responseJson.flags || []
@@ -464,11 +468,32 @@ function matchProperty(
 
   const overrideValue = propertyValues[key]
 
+  function computeExactMatch(value: any, overrideValue: any): boolean {
+    if (Array.isArray(value)) {
+      return value.map((val) => String(val).toLowerCase()).includes(String(overrideValue).toLowerCase())
+    }
+    return String(value).toLowerCase() === String(overrideValue).toLowerCase()
+  }
+
+  function compare(lhs: any, rhs: any, operator: string): boolean {
+    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: ${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
     case 'icontains':
@@ -480,25 +505,54 @@ function matchProperty(
     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
+    case 'lte': {
+      // :TRICKY: We adjust comparison based on the override value passed in,
+      // to make sure we handle both numeric and string comparisons appropriately.
+      let 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': {
-      const parsedDate = convertToDateTime(value)
+    case 'is_date_before':
+    case 'is_relative_date_before':
+    case 'is_relative_date_after': {
+      let 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: ${value}`)
+      }
       const overrideDate = convertToDateTime(overrideValue)
-      if (operator === 'is_date_before') {
+      if (['is_date_before', 'is_relative_date_before'].includes(operator)) {
         return overrideDate < parsedDate
       }
       return overrideDate > parsedDate
     }
     default:
-      console.error(`Unknown operator: ${operator}`)
-      return false
+      throw new InconclusiveMatchError(`Unknown operator: ${operator}`)
   }
 }
 
@@ -636,4 +690,47 @@ function convertToDateTime(value: string | number | (string | number)[] | Date):
   }
 }
 
-export { FeatureFlagsPoller, matchProperty, InconclusiveMatchError, ClientError }
+function relativeDateParseForFeatureFlagMatching(value: string): Date | null {
+  const regex = /^(?<number>[0-9]+)(?<interval>[a-z])$/
+  const match = value.match(regex)
+  const parsedDt = new Date(new Date().toISOString())
+
+  if (match) {
+    if (!match.groups) {
+      return null
+    }
+
+    const number = parseInt(match.groups['number'])
+
+    if (number >= 10000) {
+      // Guard against overflow, disallow numbers greater than 10_000
+      return null
+    }
+    const 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
+  }
+}
+
+export {
+  FeatureFlagsPoller,
+  matchProperty,
+  relativeDateParseForFeatureFlagMatching,
+  InconclusiveMatchError,
+  ClientError,
+}

package/src/posthog-node.ts

@@ -105,26 +105,54 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       super.captureStateless(distinctId, event, props, { timestamp, disableGeoip })
     }
 
-    if (sendFeatureFlags) {
-      super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip).then((flags) => {
-        const featureVariantProperties: Record<string, string | boolean> = {}
+    // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
+    const capturePromise = Promise.resolve()
+      .then(async () => {
+        if (sendFeatureFlags) {
+          // If we are sending feature flags, we need to make sure we have the latest flags
+          return await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)
+        }
+
+        if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
+          // Otherwise we may as well check for the flags locally and include them if there
+          const groupsWithStringValues: Record<string, string> = {}
+          for (const [key, value] of Object.entries(groups || {})) {
+            groupsWithStringValues[key] = String(value)
+          }
+
+          return await this.getAllFlags(distinctId, {
+            groups: groupsWithStringValues,
+            disableGeoip,
+            onlyEvaluateLocally: true,
+          })
+        }
+        return {}
+      })
+      .then((flags) => {
+        // Derive the relevant flag properties to add
+        const additionalProperties: Record<string, any> = {}
         if (flags) {
           for (const [feature, variant] of Object.entries(flags)) {
-            if (variant !== false) {
-              featureVariantProperties[`$feature/${feature}`] = variant
-            }
+            additionalProperties[`$feature/${feature}`] = variant
           }
         }
         const activeFlags = Object.keys(flags || {}).filter((flag) => flags?.[flag] !== false)
-        const flagProperties = {
-          $active_feature_flags: activeFlags || undefined,
-          ...featureVariantProperties,
+        if (activeFlags.length > 0) {
+          additionalProperties['$active_feature_flags'] = activeFlags
         }
-        _capture({ ...properties, $groups: groups, ...flagProperties })
+
+        return additionalProperties
       })
-    } else {
-      _capture({ ...properties, $groups: groups })
-    }
+      .catch(() => {
+        // Something went wrong getting the flag info - we should capture the event anyways
+        return {}
+      })
+      .then((additionalProperties) => {
+        // No matter what - capture the event
+        _capture({ ...additionalProperties, ...properties, $groups: groups })
+      })
+
+    this.addPendingPromise(capturePromise)
   }
 
   identify({ distinctId, properties, disableGeoip }: IdentifyMessageV1): void {
@@ -156,8 +184,18 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       disableGeoip?: boolean
     }
   ): Promise<string | boolean | undefined> {
-    const { groups, personProperties, groupProperties, disableGeoip } = options || {}
-    let { onlyEvaluateLocally, sendFeatureFlagEvents } = options || {}
+    const { groups, disableGeoip } = options || {}
+    let { onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties } = options || {}
+
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(
+      distinctId,
+      groups,
+      personProperties,
+      groupProperties
+    )
+
+    personProperties = adjustedProperties.allPersonProperties
+    groupProperties = adjustedProperties.allGroupProperties
 
     // set defaults
     if (onlyEvaluateLocally == undefined) {
@@ -232,8 +270,19 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       disableGeoip?: boolean
     }
   ): Promise<JsonType | undefined> {
-    const { groups, personProperties, groupProperties, disableGeoip } = options || {}
-    let { onlyEvaluateLocally, sendFeatureFlagEvents } = options || {}
+    const { groups, disableGeoip } = options || {}
+    let { onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties } = options || {}
+
+    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
@@ -324,8 +373,18 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       disableGeoip?: boolean
     }
   ): Promise<PosthogFlagsAndPayloadsResponse> {
-    const { groups, personProperties, groupProperties, disableGeoip } = options || {}
-    let { onlyEvaluateLocally } = options || {}
+    const { groups, disableGeoip } = options || {}
+    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {}
+
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(
+      distinctId,
+      groups,
+      personProperties,
+      groupProperties
+    )
+
+    personProperties = adjustedProperties.allPersonProperties
+    groupProperties = adjustedProperties.allGroupProperties
 
     // set defaults
     if (onlyEvaluateLocally == undefined) {
@@ -385,4 +444,25 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     this.featureFlagsPoller?.stopPoller()
     return super.shutdownAsync()
   }
+
+  private addLocalPersonAndGroupProperties(
+    distinctId: string,
+    groups?: Record<string, string>,
+    personProperties?: Record<string, string>,
+    groupProperties?: Record<string, Record<string, string>>
+  ): { allPersonProperties: Record<string, string>; allGroupProperties: Record<string, Record<string, string>> } {
+    const allPersonProperties = { $current_distinct_id: distinctId, ...(personProperties || {}) }
+
+    const allGroupProperties: Record<string, Record<string, string>> = {}
+    if (groups) {
+      for (const groupName of Object.keys(groups)) {
+        allGroupProperties[groupName] = {
+          $group_key: groups[groupName],
+          ...(groupProperties?.[groupName] || {}),
+        }
+      }
+    }
+
+    return { allPersonProperties, allGroupProperties }
+  }
 }

package/test/extensions/sentry-integration.spec.ts

@@ -3,6 +3,7 @@ import { PostHog as PostHog } from '../../src/posthog-node'
 import { PostHogSentryIntegration } from '../../src/extensions/sentry-integration'
 jest.mock('../../src/fetch')
 import fetch from '../../src/fetch'
+import { waitForPromises } from 'posthog-core/test/test-utils/test-utils'
 
 jest.mock('../../package.json', () => ({ version: '1.2.3' }))
 
@@ -108,6 +109,7 @@ describe('PostHogSentryIntegration', () => {
 
     processorFunction(createMockSentryException())
 
+    await waitForPromises()
     jest.runOnlyPendingTimers()
     const batchEvents = getLastBatchEvents()