Make async

packages/node/src/integrations/contextlines.ts

@@ -1,13 +1,19 @@
-import { getCurrentHub } from '@sentry/core';
 import { Event, EventProcessor, Integration } from '@sentry/types';
 import { addContextToFrame } from '@sentry/utils';
-import { readFileSync } from 'fs';
+import { readFile } from 'fs';
 import { LRUMap } from 'lru_map';
 
-import { NodeClient } from '../client';
-
 const FILE_CONTENT_CACHE = new LRUMap<string, string | null>(100);
 
+function readTextFileAsync(path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    readFile(path, 'utf8', (err, data) => {
+      if (err) reject(err);
+      else resolve(data);
+    });
+  });
+}
+
 /**
  * Resets the file cache. Exists for testing purposes.
  * @hidden
@@ -16,9 +22,9 @@ export function resetFileContentCache(): void {
   FILE_CONTENT_CACHE.clear();
 }
 
-type ContextLinesOptions = {
+interface ContextLinesOptions {
   frameContextLines?: number;
-};
+}
 
 /** Add node modules / packages to the event */
 export class ContextLines implements Integration {
@@ -32,27 +38,18 @@ export class ContextLines implements Integration {
    */
   public name: string = ContextLines.id;
 
-  private _linesOfContext?: number;
-
-  public constructor(options: ContextLinesOptions = {}) {
-    this._linesOfContext = options.frameContextLines;
-  }
+  public constructor(private readonly _options: ContextLinesOptions = {}) {}
 
   /**
    * @inheritDoc
    */
   public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void): void {
-    const optLinesOfContext = getCurrentHub()
-      .getClient<NodeClient>()
-      ?.getOptions()?.frameContextLines;
-
-    addGlobalEventProcessor(event => this.process(event, optLinesOfContext));
+    addGlobalEventProcessor(event => this.addToEvent(event));
   }
 
   /** Processes an event and adds context lines */
-  public process(event: Event, optLinesOfContext?: number): Event {
-    const contextLines =
-      optLinesOfContext != undefined ? optLinesOfContext : this._linesOfContext != undefined ? this._linesOfContext : 7;
+  public async addToEvent(event: Event): Promise<Event> {
+    const contextLines = this._options.frameContextLines != undefined ? this._options.frameContextLines : 7;
 
     const frames = event.exception?.values?.[0].stacktrace?.frames;
 
@@ -65,7 +62,7 @@ export class ContextLines implements Integration {
         }
       }
 
-      const sourceFiles = readSourceFiles(filenames);
+      const sourceFiles = await readSourceFiles(filenames);
 
       for (const frame of frames) {
         if (frame.filename && sourceFiles[frame.filename]) {
@@ -91,7 +88,7 @@ export class ContextLines implements Integration {
  *
  * @param filenames Array of filepaths to read content from.
  */
-function readSourceFiles(filenames: string[]): Record<string, string | null> {
+async function readSourceFiles(filenames: string[]): Promise<Record<string, string | null>> {
   // we're relying on filenames being de-duped already
   if (!filenames.length) {
     return {};
@@ -113,11 +110,11 @@ function readSourceFiles(filenames: string[]): Record<string, string | null> {
       continue;
     }
 
-    let content: string | null;
+    let content: string | null = null;
     try {
-      content = readFileSync(filename, 'utf8');
-    } catch (_e) {
-      content = null;
+      content = await readTextFileAsync(filename);
+    } catch (_) {
+      //
     }
 
     FILE_CONTENT_CACHE.set(filename, content);

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

@@ -176,9 +176,9 @@ describe('SentryNode', () => {
             expect(event.exception).not.toBeUndefined();
             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(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].stacktrace!.frames![1]).not.toBeUndefined();
+            expect(event.exception!.values![0].stacktrace!.frames![1].pre_context).not.toBeUndefined();
+            expect(event.exception!.values![0].stacktrace!.frames![1].post_context).not.toBeUndefined();
             expect(event.exception!.values![0].type).toBe('Error');
             expect(event.exception!.values![0].value).toBe('test');
             expect(event.exception!.values![0].stacktrace).toBeTruthy();

packages/node/test/parsers.test.ts

@@ -11,12 +11,12 @@ describe('parsers.ts', () => {
   let spy: jest.SpyInstance;
   let contextLines: ContextLines;
 
-  function addContext(frames: StackFrame[]) {
-    contextLines.process({ exception: { values: [{ stacktrace: { frames } }] } });
+  async function addContext(frames: StackFrame[]): Promise<void> {
+    await contextLines.addToEvent({ exception: { values: [{ stacktrace: { frames } }] } });
   }
 
   beforeEach(() => {
-    spy = jest.spyOn(fs, 'readFileSync');
+    spy = jest.spyOn(fs, 'readFile');
     frames = stacktrace.parse(new Error('test'));
     contextLines = new ContextLines();
     resetFileContentCache();
@@ -27,22 +27,22 @@ describe('parsers.ts', () => {
   });
 
   describe('lru file cache', () => {
-    test('parseStack with same file', () => {
+    test('parseStack with same file', async () => {
       expect.assertions(1);
 
       let mockCalls = 0;
       let parsedFrames = Parsers.parseStack(frames);
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
 
       mockCalls = spy.mock.calls.length;
       parsedFrames = Parsers.parseStack(frames);
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
 
       // Calls to readFile shouldn't increase if there isn't a new error
       expect(spy).toHaveBeenCalledTimes(mockCalls);
     });
 
-    test('parseStack with ESM module names', () => {
+    test('parseStack with ESM module names', async () => {
       expect.assertions(1);
 
       const framesWithFilePath: stacktrace.StackFrame[] = [
@@ -57,31 +57,31 @@ describe('parsers.ts', () => {
         },
       ];
       const parsedFrames = Parsers.parseStack(framesWithFilePath);
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
       expect(spy).toHaveBeenCalledTimes(1);
     });
 
-    test('parseStack with adding different file', () => {
+    test('parseStack with adding different file', async () => {
       expect.assertions(2);
       let mockCalls = 0;
       let newErrorCalls = 0;
       let parsedFrames = Parsers.parseStack(frames);
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
 
       mockCalls = spy.mock.calls.length;
       parsedFrames = Parsers.parseStack(stacktrace.parse(getError()));
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
 
       newErrorCalls = spy.mock.calls.length;
       expect(newErrorCalls).toBeGreaterThan(mockCalls);
 
       parsedFrames = Parsers.parseStack(stacktrace.parse(getError()));
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
 
       expect(spy).toHaveBeenCalledTimes(newErrorCalls);
     });
 
-    test('parseStack with duplicate files', () => {
+    test('parseStack with duplicate files', async () => {
       expect.assertions(1);
       const framesWithDuplicateFiles: stacktrace.StackFrame[] = [
         {
@@ -114,16 +114,16 @@ describe('parsers.ts', () => {
       ];
 
       const parsedFrames = Parsers.parseStack(framesWithDuplicateFiles);
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
       expect(spy).toHaveBeenCalledTimes(1);
     });
 
-    test('parseStack with no context', () => {
+    test('parseStack with no context', async () => {
       contextLines = new ContextLines({ frameContextLines: 0 });
 
       expect.assertions(1);
       const parsedFrames = Parsers.parseStack(frames);
-      addContext(parsedFrames);
+      await addContext(parsedFrames);
       expect(spy).toHaveBeenCalledTimes(0);
     });
   });