With integration

packages/node/src/backend.ts

@@ -3,7 +3,6 @@ import { Event, EventHint, Severity, Transport, TransportOptions } from '@sentry
 import { Dsn } from '@sentry/utils';
 
 import { eventFromException, eventFromMessage } from './eventbuilder';
-import { addSourcesToFrames } from './sources';
 import { HTTPSTransport, HTTPTransport } from './transports';
 import { NodeOptions } from './types';
 
@@ -17,24 +16,14 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
   public eventFromException(exception: any, hint?: EventHint): PromiseLike<Event> {
-    const event = eventFromException(this._options, exception, hint);
-
-    return addSourcesToFrames(event.stacktrace?.frames || [], this._options).then(frames => {
-      event.stacktrace = { frames };
-      return event;
-    });
+    return Promise.resolve(eventFromException(this._options, exception, hint));
   }
 
   /**
    * @inheritDoc
    */
   public eventFromMessage(message: string, level: Severity = Severity.Info, hint?: EventHint): PromiseLike<Event> {
-    const event = eventFromMessage(this._options, message, level, hint);
-
-    return addSourcesToFrames(event.stacktrace?.frames || [], this._options).then(frames => {
-      event.stacktrace = { frames };
-      return event;
-    });
+    return Promise.resolve(eventFromMessage(this._options, message, level, hint));
   }
 
   /**

packages/node/src/integrations/contextlines.ts

@@ -0,0 +1,119 @@
+import { Event, EventProcessor, Integration, StackFrame } from '@sentry/types';
+import { addContextToFrame } from '@sentry/utils';
+import { readFileSync } from 'fs';
+import { LRUMap } from 'lru_map';
+
+const FILE_CONTENT_CACHE = new LRUMap<string, string | null>(100);
+
+/**
+ * Resets the file cache. Exists for testing purposes.
+ * @hidden
+ */
+export function resetFileContentCache(): void {
+  FILE_CONTENT_CACHE.clear();
+}
+
+type ContextLinesOptions = {
+  frameContextLines?: number;
+};
+
+/** Add node modules / packages to the event */
+export class ContextLines implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'ContextLines';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = ContextLines.id;
+
+  private _linesOfContext: number;
+
+  public constructor(options: ContextLinesOptions = {}) {
+    this._linesOfContext = options.frameContextLines ?? 7;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void): void {
+    addGlobalEventProcessor(event => this.process(event));
+  }
+
+  /** Processes an event and adds context lines */
+  public process(event: Event): Event {
+    console.log(this);
+    const frames = event.exception?.values?.[0].stacktrace?.frames;
+
+    if (frames && this._linesOfContext > 0) {
+      const filenames: string[] = [];
+
+      for (const frame of frames) {
+        if (frame.filename && !filenames.includes(frame.filename)) {
+          filenames.push(frame.filename);
+        }
+      }
+
+      const sourceFiles = readSourceFiles(filenames);
+
+      for (const frame of frames) {
+        if (frame.filename && sourceFiles[frame.filename]) {
+          try {
+            const lines = (sourceFiles[frame.filename] as string).split('\n');
+            addContextToFrame(lines, frame, this._linesOfContext);
+          } catch (e) {
+            // anomaly, being defensive in case
+            // unlikely to ever happen in practice but can definitely happen in theory
+          }
+        }
+      }
+
+      return event;
+    }
+
+    return event;
+  }
+}
+
+/**
+ * This function reads file contents and caches them in a global LRU cache.
+ *
+ * @param filenames Array of filepaths to read content from.
+ */
+function readSourceFiles(filenames: string[]): Record<string, string | null> {
+  // we're relying on filenames being de-duped already
+  if (!filenames.length) {
+    return {};
+  }
+
+  const sourceFiles: Record<string, string | null> = {};
+
+  for (const filename of filenames) {
+    const cache = FILE_CONTENT_CACHE.get(filename);
+    // We have a cache hit
+    if (cache !== undefined) {
+      // If stored value is null, it means that we already tried, but couldn't read the content of the file. Skip.
+      if (cache === null) {
+        continue;
+      }
+
+      // Otherwise content is there, so reuse cached value.
+      sourceFiles[filename] = cache;
+      continue;
+    }
+
+    let content: string | null;
+    try {
+      content = readFileSync(filename, 'utf8');
+    } catch (_e) {
+      content = null;
+    }
+
+    FILE_CONTENT_CACHE.set(filename, content);
+    sourceFiles[filename] = content;
+  }
+
+  return sourceFiles;
+}

packages/node/src/integrations/index.ts

@@ -4,3 +4,4 @@ export { OnUncaughtException } from './onuncaughtexception';
 export { OnUnhandledRejection } from './onunhandledrejection';
 export { LinkedErrors } from './linkederrors';
 export { Modules } from './modules';
+export { ContextLines } from './contextlines';

packages/node/src/sdk.ts

@@ -5,7 +5,7 @@ import { getGlobalObject } from '@sentry/utils';
 import * as domain from 'domain';
 
 import { NodeClient } from './client';
-import { Console, Http, LinkedErrors, OnUncaughtException, OnUnhandledRejection } from './integrations';
+import { Console, ContextLines, Http, LinkedErrors, OnUncaughtException, OnUnhandledRejection } from './integrations';
 import { NodeOptions } from './types';
 
 export const defaultIntegrations = [
@@ -20,6 +20,8 @@ export const defaultIntegrations = [
   new OnUnhandledRejection(),
   // Misc
   new LinkedErrors(),
+  // Context Lines
+  new ContextLines(),
 ];
 
 /**

packages/node/src/types.ts

@@ -20,9 +20,6 @@ export interface NodeOptions extends Options {
   /** HTTPS proxy certificates path */
   caCerts?: string;
 
-  /** Sets the number of context lines for each frame when loading a file. */
-  frameContextLines?: number;
-
   /** Callback that is executed when a fatal global error occurs. */
   onFatalError?(error: Error): void;
 }

packages/node/test/index.test.ts

@@ -167,7 +167,7 @@ describe('SentryNode', () => {
       }
     });
 
-    test('capture an exception no pre/post context', done => {
+    test('capture an exception with pre/post context', done => {
       expect.assertions(10);
       getCurrentHub().bindClient(
         new NodeClient({
@@ -177,16 +177,15 @@ describe('SentryNode', () => {
             expect(event.exception!.values![0]).not.toBeUndefined();
             expect(event.exception!.values![0].stacktrace!).not.toBeUndefined();
             expect(event.exception!.values![0].stacktrace!.frames![2]).not.toBeUndefined();
-            expect(event.exception!.values![0].stacktrace!.frames![2].pre_context).toBeUndefined();
-            expect(event.exception!.values![0].stacktrace!.frames![2].post_context).toBeUndefined();
+            expect(Array.isArray(event.exception!.values![0].stacktrace!.frames![2].pre_context)).toBe(true);
+            expect(Array.isArray(event.exception!.values![0].stacktrace!.frames![2].post_context)).toBe(true);
             expect(event.exception!.values![0].type).toBe('Error');
             expect(event.exception!.values![0].value).toBe('test');
             expect(event.exception!.values![0].stacktrace).toBeTruthy();
             done();
             return null;
           },
           dsn,
-          frameContextLines: 0,
         }),
       );
       configureScope((scope: Scope) => {