ref(node): Refactor node source fetching into integration

packages/nextjs/test/index.server.test.ts

@@ -1,4 +1,3 @@
-import { BaseClient } from '@sentry/core';
 import { RewriteFrames } from '@sentry/integrations';
 import * as SentryNode from '@sentry/node';
 import { getCurrentHub, NodeClient } from '@sentry/node';
@@ -17,7 +16,6 @@ const global = getGlobalObject();
 (global as typeof global & { __rewriteFramesDistDir__: string }).__rewriteFramesDistDir__ = '.next';
 
 const nodeInit = jest.spyOn(SentryNode, 'init');
-const captureEvent = jest.spyOn(BaseClient.prototype, 'captureEvent');
 const logError = jest.spyOn(logger, 'error');
 
 describe('Server init()', () => {
@@ -91,7 +89,7 @@ describe('Server init()', () => {
  expect(currentScope._tags.vercel).toBeUndefined();
  });
 
- it('adds 404 transaction filter', () => {
+ it('adds 404 transaction filter', async () => {
  init({
  dsn: 'https://dogsarebadatkeepingsecrets@squirrelchasers.ingest.sentry.io/12312012',
  tracesSampleRate: 1.0,
@@ -102,8 +100,10 @@ describe('Server init()', () => {
  const transaction = hub.startTransaction({ name: '/404' });
  transaction.finish();
 
+ // We need to flush because the event processor pipeline is async whereas transaction.finish() is sync.
+ await SentryNode.flush();
+
  expect(sendEvent).not.toHaveBeenCalled();
- expect(captureEvent.mock.results[0].value).toBeUndefined();
  expect(logError).toHaveBeenCalledWith(new SentryError('An event processor returned null, will not send event.'));
  });
 

packages/node/src/backend.ts

@@ -16,7 +16,7 @@ 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> {
- return eventFromException(this._options, exception, hint);
+ return eventFromException(exception, hint);
  }
 
  /**

packages/node/src/eventbuilder.ts

@@ -16,7 +16,7 @@ import { extractStackFromError, parseError, parseStack, prepareFramesForEvent }
  * Builds and Event from a Exception
  * @hidden
  */
-export function eventFromException(options: Options, exception: unknown, hint?: EventHint): PromiseLike<Event> {
+export function eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  let ex: any = exception;
  const providedMechanism: Mechanism | undefined =
@@ -48,7 +48,7 @@ export function eventFromException(options: Options, exception: unknown, hint?:
  }
 
  return new SyncPromise<Event>((resolve, reject) =>
- parseError(ex as Error, options)
+ parseError(ex as Error)
  .then(event => {
  addExceptionTypeValue(event, undefined, undefined);
  addExceptionMechanism(event, mechanism);
@@ -81,16 +81,11 @@ export function eventFromMessage(
  return new SyncPromise<Event>(resolve => {
  if (options.attachStacktrace && hint && hint.syntheticException) {
  const stack = hint.syntheticException ? extractStackFromError(hint.syntheticException) : [];
- void parseStack(stack, options)
- .then(frames => {
- event.stacktrace = {
- frames: prepareFramesForEvent(frames),
- };
- resolve(event);
- })
- .then(null, () => {
- resolve(event);
- });
+ const frames = parseStack(stack);
+ event.stacktrace = {
+ frames: prepareFramesForEvent(frames),
+ };
+ resolve(event);
  } else {
  resolve(event);
  }

packages/node/src/integrations/contextlines.ts

@@ -0,0 +1,140 @@
+import { getCurrentHub } from '@sentry/core';
+import { Event, EventProcessor, Integration } from '@sentry/types';
+import { addContextToFrame } from '@sentry/utils';
+import { readFile } from 'fs';
+import { LRUMap } from 'lru_map';
+
+import { NodeClient } from '../client';
+
+const FILE_CONTENT_CACHE = new LRUMap<string, string | null>(100);
+const DEFAULT_LINES_OF_CONTEXT = 7;
+
+// TODO: Replace with promisify when minimum supported node >= v8
+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
+ */
+export function resetFileContentCache(): void {
+ FILE_CONTENT_CACHE.clear();
+}
+
+interface ContextLinesOptions {
+ /**
+ * Sets the number of context lines for each frame when loading a file.
+ * Defaults to 7.
+ *
+ * Set to 0 to disable loading and inclusion of source files.
+ **/
+ 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;
+
+ public constructor(private readonly _options: ContextLinesOptions = {}) {}
+
+ /**
+ * @inheritDoc
+ */
+ public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void): void {
+ // This is only here to copy frameContextLines from init options if it hasn't
+ // been set via this integrations constructor.
+ //
+ // TODO: Remove on next major!
+ if (this._options.frameContextLines === undefined) {
+ const initOptions = getCurrentHub().getClient<NodeClient>()?.getOptions();
+ // eslint-disable-next-line deprecation/deprecation
+ this._options.frameContextLines = initOptions?.frameContextLines;
+ }
+
+ const contextLines =
+ this._options.frameContextLines !== undefined ? this._options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;
+
+ addGlobalEventProcessor(event => this.addSourceContext(event, contextLines));
+ }
+
+ /** Processes an event and adds context lines */
+ public async addSourceContext(event: Event, contextLines: number): Promise<Event> {
+ const frames = event.exception?.values?.[0].stacktrace?.frames;
+
+ if (frames && contextLines > 0) {
+ const filenames: Set<string> = new Set();
+
+ for (const frame of frames) {
+ if (frame.filename) {
+ filenames.add(frame.filename);
+ }
+ }
+
+ const sourceFiles = await 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, contextLines);
+ } catch (e) {
+ // anomaly, being defensive in case
+ // unlikely to ever happen in practice but can definitely happen in theory
+ }
+ }
+ }
+ }
+
+ return event;
+ }
+}
+
+/**
+ * This function reads file contents and caches them in a global LRU cache.
+ *
+ * @param filenames Array of filepaths to read content from.
+ */
+async function readSourceFiles(filenames: Set<string>): Promise<Record<string, string | null>> {
+ const sourceFiles: Record<string, string | null> = {};
+
+ for (const filename of filenames) {
+ const cachedFile = FILE_CONTENT_CACHE.get(filename);
+ // We have a cache hit
+ if (cachedFile !== undefined) {
+ // If stored value is null, it means that we already tried, but couldn't read the content of the file. Skip.
+ if (cachedFile === null) {
+ continue;
+ }
+
+ // Otherwise content is there, so reuse cached value.
+ sourceFiles[filename] = cachedFile;
+ continue;
+ }
+
+ let content: string | null = null;
+ try {
+ content = await readTextFileAsync(filename);
+ } catch (_) {
+ //
+ }
+
+ 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';