posthog-node 4.2.2 → 4.3.0

package/lib/index.d.ts

@@ -132,7 +132,7 @@ declare class SimpleEventEmitter {
 declare abstract class PostHogCoreStateless {
     readonly apiKey: string;
     readonly host: string;
-    private flushAt;
+    readonly flushAt: number;
     private maxBatchSize;
     private maxQueueSize;
     private flushInterval;
@@ -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.2";
+var version = "4.3.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -1060,7 +1060,7 @@ class PostHogCoreStateless {
     identifyStateless(distinctId, properties, options) {
         this.wrap(() => {
             // The properties passed to identifyStateless are event properties.
-            // To add person properties, pass in all person properties to the `$set` key.
+            // To add person properties, pass in all person properties to the `$set` and `$set_once` keys.
             const payload = {
                 ...this.buildPayload({
                     distinct_id: distinctId,
@@ -2159,9 +2159,14 @@ class PostHog extends PostHogCoreStateless {
     disableGeoip
   }) {
     // Catch properties passed as $set and move them to the top level
-    const personProperties = properties?.$set || properties;
+    // promote $set and $set_once to top level
+    const userPropsOnce = properties?.$set_once;
+    delete properties?.$set_once;
+    // if no $set is provided we assume all properties are $set
+    const userProps = properties?.$set || properties;
     super.identifyStateless(distinctId, {
-      $set: personProperties
+      $set: userProps,
+      $set_once: userPropsOnce
     }, {
       disableGeoip
     });
@@ -2356,6 +2361,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.
  *
@@ -2374,58 +2382,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