posthog-node 4.2.3 → 4.3.1

package/lib/index.d.ts

@@ -435,40 +435,32 @@ declare class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
  * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
  */
 
+declare const severityLevels: readonly ["fatal", "error", "warning", "log", "info", "debug"];
+declare type SeverityLevel = (typeof severityLevels)[number];
+type _SentryEvent = any;
 type _SentryEventProcessor = any;
 type _SentryHub = any;
 interface _SentryIntegration {
+    name: string;
+    processEvent(event: _SentryEvent): _SentryEvent;
+}
+interface _SentryIntegrationClass {
     name: string;
     setupOnce(addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub): void;
 }
-/**
- * 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/)
- */
-declare class PostHogSentryIntegration implements _SentryIntegration {
-    private readonly posthog;
-    private readonly posthogHost?;
-    private readonly organization?;
-    private readonly prefix?;
+type SentryIntegrationOptions = {
+    organization?: string;
+    projectId?: number;
+    prefix?: string;
+    severityAllowList?: SeverityLevel[] | '*';
+};
+declare function createEventProcessor(_posthog: PostHog, { organization, projectId, prefix, severityAllowList }?: SentryIntegrationOptions): (event: _SentryEvent) => _SentryEvent;
+declare function sentryIntegration(_posthog: PostHog, options?: SentryIntegrationOptions): _SentryIntegration;
+declare class PostHogSentryIntegration implements _SentryIntegrationClass {
     readonly name = "posthog-node";
     static readonly POSTHOG_ID_TAG = "posthog_distinct_id";
-    constructor(posthog: PostHog, posthogHost?: string | undefined, organization?: string | undefined, prefix?: string | undefined);
-    setupOnce(addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub): void;
+    setupOnce: (addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub) => void;
+    constructor(_posthog: PostHog, organization?: string, prefix?: string, severityAllowList?: SeverityLevel[] | '*');
 }
 
-export { PostHog, PostHogOptions, PostHogSentryIntegration };
+export { PostHog, PostHogOptions, PostHogSentryIntegration, SentryIntegrationOptions, SeverityLevel, createEventProcessor, sentryIntegration, severityLevels };

package/lib/index.esm.js

@@ -1,6 +1,6 @@
 import { createHash } from 'rusha';
 
-var version = "4.2.3";
+var version = "4.3.1";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -2230,44 +2230,70 @@ class PostHog extends PostHogCoreStateless {
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     const {
       groups,
-      disableGeoip
-    } = options || {};
-    let {
-      onlyEvaluateLocally,
-      sendFeatureFlagEvents,
+      disableGeoip,
+      onlyEvaluateLocally = false,
       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
-    if (!matchValue) {
+    const {
+      allPersonProperties,
+      allGroupProperties
+    } = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    if (matchValue === undefined) {
       matchValue = await this.getFeatureFlag(key, distinctId, {
         ...options,
-        onlyEvaluateLocally: true
+        onlyEvaluateLocally: true,
+        sendFeatureFlagEvents: false
       });
     }
+    let response;
+    let payload;
     if (matchValue) {
-      response = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
-    }
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
-    }
-    if (sendFeatureFlagEvents == undefined) {
-      sendFeatureFlagEvents = true;
-    }
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
+      response = matchValue;
+      payload = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
+    } else {
+      response = undefined;
+      payload = undefined;
     }
-    const payloadWasLocallyEvaluated = response !== undefined;
-    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
-      response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+    // 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 || {};
     }
-    return response;
+    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;
   }
   async isFeatureEnabled(key, distinctId, options) {
     const feat = await this.getFeatureFlag(key, distinctId, options);
@@ -2361,6 +2387,9 @@ class PostHog extends PostHogCoreStateless {
   }
 }
 
+/**
+ * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
+ */
 /**
  * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
  *
@@ -2379,58 +2408,92 @@ class PostHog extends PostHogCoreStateless {
  * @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/)
+ * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
  */
-class PostHogSentryIntegration {
-  constructor(posthog, posthogHost, organization, prefix) {
-    this.posthog = posthog;
-    this.posthogHost = posthogHost;
-    this.organization = organization;
-    this.prefix = prefix;
-    this.name = 'posthog-node';
-    this.posthogHost = posthog.options.host ?? 'https://us.i.posthog.com';
-  }
-  setupOnce(addGlobalEventProcessor, getCurrentHub) {
-    addGlobalEventProcessor(event => {
-      if (event.exception?.values === undefined || event.exception.values.length === 0) {
-        return event;
-      }
-      if (!event.tags) {
-        event.tags = {};
-      }
-      const sentry = getCurrentHub();
-      // Get the PostHog user ID from a specific tag, which users can set on their Sentry scope as they need.
-      const 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/${userId}`, this.posthogHost).toString();
-      const properties = {
-        // PostHog Exception Properties
-        $exception_message: event.exception.values[0]?.value,
-        $exception_type: event.exception.values[0]?.type,
-        $exception_personURL: event.tags['PostHog Person URL'],
-        // Sentry Exception Properties
-        $sentry_event_id: event.event_id,
-        $sentry_exception: event.exception,
-        $sentry_exception_message: event.exception.values[0]?.value,
-        $sentry_exception_type: event.exception.values[0]?.type,
-        $sentry_tags: event.tags
-      };
-      const projectId = sentry.getClient()?.getDsn()?.projectId;
-      if (this.organization !== undefined && projectId !== undefined && event.event_id !== undefined) {
-        properties.$sentry_url = `${this.prefix ?? 'https://sentry.io/organizations'}/${this.organization}/issues/?project=${projectId}&query=${event.event_id}`;
-      }
-      this.posthog.capture({
-        event: '$exception',
-        distinctId: userId,
-        properties
-      });
+const severityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];
+const NAME = 'posthog-node';
+function createEventProcessor(_posthog, {
+  organization,
+  projectId,
+  prefix,
+  severityAllowList = ['error']
+} = {}) {
+  return event => {
+    const shouldProcessLevel = severityAllowList === '*' || severityAllowList.includes(event.level);
+    if (!shouldProcessLevel) {
       return event;
+    }
+    if (!event.tags) {
+      event.tags = {};
+    }
+    // Get the PostHog user ID from a specific tag, which users can set on their Sentry scope as they need.
+    const 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;
+    }
+    const uiHost = _posthog.options.host ?? 'https://us.i.posthog.com';
+    const personUrl = new URL(`/project/${_posthog.apiKey}/person/${userId}`, uiHost).toString();
+    event.tags['PostHog Person URL'] = personUrl;
+    const exceptions = event.exception?.values || [];
+    exceptions.map(exception => {
+      if (exception.stacktrace) {
+        exception.stacktrace.type = 'raw';
+      }
+    });
+    const properties = {
+      // PostHog Exception Properties,
+      $exception_message: exceptions[0]?.value || event.message,
+      $exception_type: exceptions[0]?.type,
+      $exception_personURL: personUrl,
+      $exception_level: event.level,
+      $exception_list: exceptions,
+      // Sentry Exception Properties
+      $sentry_event_id: event.event_id,
+      $sentry_exception: event.exception,
+      $sentry_exception_message: exceptions[0]?.value || event.message,
+      $sentry_exception_type: exceptions[0]?.type,
+      $sentry_tags: event.tags
+    };
+    if (organization && projectId) {
+      properties['$sentry_url'] = (prefix || 'https://sentry.io/organizations/') + organization + '/issues/?project=' + projectId + '&query=' + event.event_id;
+    }
+    _posthog.capture({
+      event: '$exception',
+      distinctId: userId,
+      properties
     });
+    return event;
+  };
+}
+// V8 integration - function based
+function sentryIntegration(_posthog, options) {
+  const processor = createEventProcessor(_posthog, options);
+  return {
+    name: NAME,
+    processEvent(event) {
+      return processor(event);
+    }
+  };
+}
+// V7 integration - class based
+class PostHogSentryIntegration {
+  constructor(_posthog, organization, prefix, severityAllowList) {
+    this.name = NAME;
+    // setupOnce gets called by Sentry when it intializes the plugin
+    this.name = NAME;
+    this.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {
+      const projectId = getCurrentHub()?.getClient()?.getDsn()?.projectId;
+      addGlobalEventProcessor(createEventProcessor(_posthog, {
+        organization,
+        projectId,
+        prefix,
+        severityAllowList
+      }));
+    };
   }
 }
 PostHogSentryIntegration.POSTHOG_ID_TAG = 'posthog_distinct_id';
 
-export { PostHog, PostHogSentryIntegration };
+export { PostHog, PostHogSentryIntegration, createEventProcessor, sentryIntegration, severityLevels };
 //# sourceMappingURL=index.esm.js.map