feat: Make node transactions a pluggable integration with tests

Author: kamilogorek

packages/node/src/integrations/pluggable/transaction.ts

@@ -0,0 +1,51 @@
+import { Scope } from '@sentry/hub';
+import { Integration, SentryEvent, StackFrame } from '@sentry/types';
+import { NodeOptions } from '../../backend';
+import { getCurrentHub } from '../../hub';
+
+/** Add node transaction to the event */
+export class Transaction implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public name: string = 'Transaction';
+
+  /**
+   * @inheritDoc
+   */
+  public install(_: NodeOptions = {}): void {
+    getCurrentHub().configureScope((scope: Scope) => {
+      scope.addEventProcessor(async event => this.process(event));
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public async process(event: SentryEvent): Promise<SentryEvent> {
+    const frames = this.getFramesFromEvent(event);
+
+    // use for loop so we don't have to reverse whole frames array
+    for (let i = frames.length - 1; i >= 0; i--) {
+      const frame = frames[i];
+
+      if (frame.in_app === true) {
+        event.transaction = this.getTransaction(frame);
+        break;
+      }
+    }
+
+    return event;
+  }
+
+  /** JSDoc */
+  private getFramesFromEvent(event: SentryEvent): StackFrame[] {
+    const exception = event.exception && event.exception.values && event.exception.values[0];
+    return (exception && exception.stacktrace && exception.stacktrace.frames) || [];
+  }
+
+  /** JSDoc */
+  private getTransaction(frame: StackFrame): string {
+    return frame.module || frame.function ? `${frame.module || '?'}/${frame.function || '?'}` : '<unknown>';
+  }
+}

packages/node/src/parsers.ts

@@ -25,11 +25,6 @@ function getFunction(frame: stacktrace.StackFrame): string {
   }
 }
 
-/** JSDoc */
-function getTransaction(frame: StackFrame): string {
-  return frame.module || frame.function ? `${frame.module || '?'} at ${frame.function || '?'}` : '<unknown>';
-}
-
 const mainModule: string = `${(require.main && require.main.filename && path.dirname(require.main.filename)) ||
   global.process.cwd()}/`;
 
@@ -216,17 +211,6 @@ export async function parseError(error: ExtendedError): Promise<SentryEvent> {
     };
   }
 
-  // use for loop so we don't have to reverse whole frames array
-  const frames = (exception.stacktrace && exception.stacktrace.frames) || [];
-  for (let i = frames.length - 1; i >= 0; i--) {
-    const frame = frames[i];
-
-    if (frame.in_app === true) {
-      event.transaction = getTransaction(frame);
-      break;
-    }
-  }
-
   return event;
 }
 

packages/node/test/integrations/transaction.test.ts

@@ -0,0 +1,135 @@
+import { Transaction } from '../../src/integrations/pluggable/transaction';
+
+const transaction: Transaction = new Transaction();
+
+describe.only('Transaction', () => {
+  describe('extracts info from module/function of the first `in_app` frame', () => {
+    it('using module only', async () => {
+      const event = await transaction.process({
+        exception: {
+          values: [
+            {
+              stacktrace: {
+                frames: [
+                  {
+                    filename: '/some/file1.js',
+                    in_app: false,
+                    module: 'Foo',
+                  },
+                  {
+                    filename: '/some/file2.js',
+                    in_app: true,
+                    module: 'Qux',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      });
+      expect(event.transaction).toEqual('Qux/?');
+    });
+
+    it('using function only', async () => {
+      const event = await transaction.process({
+        exception: {
+          values: [
+            {
+              stacktrace: {
+                frames: [
+                  {
+                    filename: '/some/file1.js',
+                    function: 'Bar',
+                    in_app: false,
+                  },
+                  {
+                    filename: '/some/file2.js',
+                    function: 'Baz',
+                    in_app: true,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      });
+      expect(event.transaction).toEqual('?/Baz');
+    });
+
+    it('using module and function', async () => {
+      const event = await transaction.process({
+        exception: {
+          values: [
+            {
+              stacktrace: {
+                frames: [
+                  {
+                    filename: '/some/file1.js',
+                    function: 'Bar',
+                    in_app: true,
+                    module: 'Foo',
+                  },
+                  {
+                    filename: '/some/file2.js',
+                    function: 'Baz',
+                    in_app: false,
+                    module: 'Qux',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      });
+      expect(event.transaction).toEqual('Foo/Bar');
+    });
+
+    it('using default', async () => {
+      const event = await transaction.process({
+        exception: {
+          values: [
+            {
+              stacktrace: {
+                frames: [
+                  {
+                    filename: '/some/file1.js',
+                    in_app: false,
+                  },
+                  {
+                    filename: '/some/file2.js',
+                    in_app: true,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      });
+      expect(event.transaction).toEqual('<unknown>');
+    });
+
+    it('no value with no `in_app` frame', async () => {
+      const event = await transaction.process({
+        exception: {
+          values: [
+            {
+              stacktrace: {
+                frames: [
+                  {
+                    filename: '/some/file1.js',
+                    in_app: false,
+                  },
+                  {
+                    filename: '/some/file2.js',
+                    in_app: false,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      });
+      expect(event.transaction).toBeUndefined();
+    });
+  });
+});