ref(node): Streamline vendored fs instrumentation

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';
 

.oxlintrc.base.json

@@ -142,7 +142,6 @@
  },
  {
  "files": [
- "**/integrations/fs/vendored/**/*.ts",
  "**/integrations/tracing/knex/vendored/**/*.ts",
  "**/integrations/tracing/mongo/vendored/**/*.ts",
  "**/integrations/tracing/graphql/vendored/**/*.ts",

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-errors-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record error messages - file paths must NOT be recorded
+ Sentry.fsIntegration({
+ recordErrorMessagesAsSpanAttributes: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/server-record-paths-only.ts

@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+ dsn: 'https://public@dsn.ingest.sentry.io/1337',
+ release: '1.0',
+ transport: loggingTransport,
+ tracesSampleRate: 1,
+ integrations: [
+ // Only record file paths - error messages must NOT be recorded
+ Sentry.fsIntegration({
+ recordFilePaths: true,
+ }),
+ ],
+});
+
+import express from 'express';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const app = express();
+
+app.get('/readFile', async (_, res) => {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file.txt'), 'utf-8');
+ res.send('done');
+});
+
+app.get('/readFile-error', async (_, res) => {
+ try {
+ await fs.promises.readFile(path.join(__dirname, 'fixtures', 'some-file-that-doesnt-exist.txt'), 'utf-8');
+ } catch {
+ // noop
+ }
+ res.send('done');
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/fs-instrumentation/test.ts

@@ -271,3 +271,83 @@ test('should create spans for fs operations that take target argument', async ()
  expect(result).toEqual('done');
  await runner.completed();
 });
+
+test('records file path but not error messages when only `recordFilePaths` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-paths-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `path_argument` is recorded, but `fs_error` is NOT, since `recordErrorMessagesAsSpanAttributes` is off
+ data: {
+ path_argument: expect.stringMatching('/fixtures/some-file-that-doesnt-exist.txt'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('records error messages but not file paths when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile-error',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'internal_error',
+ // `fs_error` is recorded, but `path_argument` is NOT, since `recordFilePaths` is off
+ data: {
+ fs_error: expect.stringMatching('ENOENT: no such file or directory,'),
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile-error');
+ expect(result).toEqual('done');
+ await runner.completed();
+});
+
+test('does not record file paths on successful operations when only `recordErrorMessagesAsSpanAttributes` is enabled', async () => {
+ const runner = createRunner(__dirname, 'server-record-errors-only.ts')
+ .expect({
+ transaction: {
+ transaction: 'GET /readFile',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ description: 'fs.readFile',
+ op: 'file',
+ status: 'ok',
+ // Neither `path_argument` nor `fs_error` are recorded
+ data: {
+ [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+ },
+ }),
+ ]),
+ },
+ })
+ .start();
+
+ const result = await runner.makeRequest('get', '/readFile');
+ expect(result).toEqual('done');
+ await runner.completed();
+});

packages/node/src/integrations/fs/index.ts

@@ -1,6 +1,6 @@
-import { FsInstrumentation } from './vendored/instrumentation';
-import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import { generateInstrumentOnce } from '@sentry/node-core';
+import { FsInstrumentation } from './vendored/instrumentation';
 
 const INTEGRATION_NAME = 'FileSystem';
 
@@ -38,112 +38,11 @@ export const fsIntegration = defineIntegration(
  INTEGRATION_NAME,
  () =>
  new FsInstrumentation({
- requireParentSpan: true,
- endHook(functionName, { args, span, error }) {
- span.updateName(`fs.${functionName}`);
-
- span.setAttributes({
- [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
- [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
- });
-
- if (options.recordErrorMessagesAsSpanAttributes) {
- if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
- span.setAttribute('path_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
- ) {
- span.setAttribute('target_argument', args[0]);
- span.setAttribute('path_argument', args[1]);
- } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
- span.setAttribute('prefix_argument', args[0]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('existing_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
- ) {
- span.setAttribute('src_argument', args[0]);
- span.setAttribute('dest_argument', args[1]);
- } else if (
- typeof args[0] === 'string' &&
- typeof args[1] === 'string' &&
- FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
- ) {
- span.setAttribute('old_path_argument', args[0]);
- span.setAttribute('new_path_argument', args[1]);
- }
- }
-
- if (error && options.recordErrorMessagesAsSpanAttributes) {
- span.setAttribute('fs_error', error.message);
- }
- },
+ recordFilePaths: options.recordFilePaths,
+ recordErrorMessagesAsSpanAttributes: options.recordErrorMessagesAsSpanAttributes,
  }),
  )();
  },
  };
  },
 );
-
-const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
-const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
-const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
-const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
-const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
-const FS_OPERATIONS_WITH_PATH_ARG = [
- 'access',
- 'appendFile',
- 'chmod',
- 'chown',
- 'exists',
- 'mkdir',
- 'lchown',
- 'lstat',
- 'lutimes',
- 'open',
- 'opendir',
- 'readdir',
- 'readFile',
- 'readlink',
- 'realpath',
- 'realpath.native',
- 'rm',
- 'rmdir',
- 'stat',
- 'truncate',
- 'unlink',
- 'utimes',
- 'writeFile',
- 'accessSync',
- 'appendFileSync',
- 'chmodSync',
- 'chownSync',
- 'existsSync',
- 'lchownSync',
- 'lstatSync',
- 'lutimesSync',
- 'opendirSync',
- 'mkdirSync',
- 'openSync',
- 'readdirSync',
- 'readFileSync',
- 'readlinkSync',
- 'realpathSync',
- 'realpathSync.native',
- 'rmdirSync',
- 'rmSync',
- 'statSync',
- 'truncateSync',
- 'unlinkSync',
- 'utimesSync',
- 'writeFileSync',
-];

packages/node/src/integrations/fs/vendored/constants.ts

@@ -17,7 +17,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-fs
  * - Upstream version: @opentelemetry/instrumentation-fs@0.37.0
  */
-/* eslint-disable */
 
 import type { FMember, FPMember } from './types';