From a369681e6358372a17d4526ff31b510bbe31e38f Mon Sep 17 00:00:00 2001 From: gflachs Date: Tue, 25 Feb 2025 11:57:01 +0100 Subject: [PATCH 1/6] fix!:Mysql2 Instrumentation: Masking of statements MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Issue: #1758 extend the MySQL2InstrumentationConfig with two variables: * maskStatementHook → This hook is used to escape SQL statements (optional) * maskStatement → Boolean (default: true), determines whether the maskStatementHook is applied at all default maskStatementHook: `return query.replace(/\b\d+\b/g, '?').replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?')` --- .../src/instrumentation.ts | 12 +- .../src/types.ts | 19 ++ .../src/utils.ts | 44 +++-- .../test/mysql.test.ts | 167 ++++++++++++++++++ 4 files changed, 227 insertions(+), 15 deletions(-) diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts index d22db9a020..2cb7da960d 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts @@ -137,13 +137,20 @@ export class MySQL2Instrumentation extends InstrumentationBase { diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/types.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/types.ts index 01e9f8a434..dc264f477a 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/src/types.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/types.ts @@ -25,7 +25,26 @@ export interface MySQL2InstrumentationExecutionResponseHook { (span: Span, responseHookInfo: MySQL2ResponseHookInformation): void; } +export interface MySQL2InstrumentationQueryMaskingHook { + (query: string): string; +} + export interface MySQL2InstrumentationConfig extends InstrumentationConfig { + /** + * If true, the query will be masked before setting it as a span attribute, using the {@link maskStatementHook}. + * + * @default true + * @see maskStatementHook + */ + maskStatement?: boolean; + + /** + * Hook that allows masking the query string before setting it as span attribute. + * + * @default (query: string) => query.replace(/\b\d+\b/g, '?').replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?') + */ + maskStatementHook?: MySQL2InstrumentationQueryMaskingHook; + /** * Hook that allows adding custom span attributes based on the data * returned MySQL2 queries. diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts index 9e495a7d2c..e3b62c8b3a 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts @@ -23,6 +23,7 @@ import { SEMATTRS_NET_PEER_PORT, } from '@opentelemetry/semantic-conventions'; import type * as mysqlTypes from 'mysql2'; +import { MySQL2InstrumentationQueryMaskingHook } from './types'; type formatType = typeof mysqlTypes.format; @@ -107,22 +108,41 @@ function getJDBCString( export function getDbStatement( query: string | Query | QueryOptions, format?: formatType, - values?: any[] + values?: any[], + maskStatement: boolean = true, + maskStatementHook: MySQL2InstrumentationQueryMaskingHook = defaultMaskingHook ): string { - if (!format) { - return typeof query === 'string' ? query : query.sql; - } - if (typeof query === 'string') { - return values ? format(query, values) : query; - } else { - // According to https://github.com/mysqljs/mysql#performing-queries - // The values argument will override the values in the option object. - return values || (query as QueryOptions).values - ? format(query.sql, values || (query as QueryOptions).values) - : query.sql; + let formattedQuery: string; + try { + if (!format) { + formattedQuery = typeof query === 'string' ? query : query.sql; + } else if (typeof query === 'string') { + formattedQuery = values ? format(query, values) : query; + } else { + // According to https://github.com/mysqljs/mysql#performing-queries + // The values argument will override the values in the option object. + formattedQuery = + values || (query as QueryOptions).values + ? format(query.sql, values || (query as QueryOptions).values) + : query.sql; + } + + return maskStatement + ? values + ? formattedQuery + : maskStatementHook(formattedQuery) + : formattedQuery; + } catch (e) { + return 'Could not determine the query due to an error in masking or formatting'; } } +function defaultMaskingHook(query: string): string { + return query + .replace(/\b\d+\b/g, '?') + .replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?'); +} + /** * The span name SHOULD be set to a low cardinality value * representing the statement executed on the database. diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts b/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts index b966900521..5f888dbac3 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts @@ -146,6 +146,9 @@ describe('mysql2', () => { contextManager = new AsyncHooksContextManager().enable(); context.setGlobalContextManager(contextManager); instrumentation.setTracerProvider(provider); + instrumentation.setConfig({ + maskStatement: false, + }); instrumentation.enable(); connection = createConnection({ port, @@ -1118,6 +1121,7 @@ describe('mysql2', () => { responseHook: (span, responseHookInfo) => { throw new Error('random failure!'); }, + maskStatement: false, }; instrumentation.setConfig(config); }); @@ -1145,6 +1149,7 @@ describe('mysql2', () => { JSON.stringify(responseHookInfo.queryResults) ); }, + maskStatement: false, }; instrumentation.setConfig(config); }); @@ -1215,6 +1220,165 @@ describe('mysql2', () => { }); }); }); + describe('#maskStatementHook', () => { + beforeEach(done => { + //create table user and insert data + rootConnection.query( + 'CREATE TABLE user (id INT, name VARCHAR(255), age INT)', + () => { + rootConnection.query( + 'INSERT INTO user (id, name, age) VALUES (1, "test", 35)', + done + ); + } + ); + }); + + afterEach(done => { + rootConnection.query('DROP TABLE user', done); + }); + describe('default maskStatementHook', () => { + beforeEach(done => { + instrumentation.setConfig({ + maskStatement: true, + }); + memoryExporter.reset(); + done(); + }); + + it('should mask string and numbers in statements', done => { + const query = + "SELECT * FROM user WHERE name = 'test' AND age = 35 AND id = 1"; + const maskedQuery = + 'SELECT * FROM user WHERE name = ? AND age = ? AND id = ?'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].name, 'test'); + assert.strictEqual(res[0].age, 35); + assert.strictEqual(res[0].id, 1); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], maskedQuery); + done(); + }); + }); + }); + }); + describe('custom maskStatementHook', () => { + beforeEach(done => { + instrumentation.setConfig({ + maskStatement: true, + maskStatementHook: query => { + return query + .replace(/\b\d+\b/g, '*') + .replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, '*'); + }, + }); + memoryExporter.reset(); + done(); + }); + + it('should mask string and numbers in statements', done => { + const query = + "SELECT * FROM user WHERE name = 'test' AND age = 35 AND id = 1"; + const maskedQuery = + 'SELECT * FROM user WHERE name = * AND age = * AND id = *'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].name, 'test'); + assert.strictEqual(res[0].age, 35); + assert.strictEqual(res[0].id, 1); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], maskedQuery); + done(); + }); + }); + }); + }); + describe('maskStatementHook with error', () => { + beforeEach(done => { + instrumentation.setConfig({ + maskStatement: true, + maskStatementHook: () => { + throw new Error('random failure!'); + }, + }); + memoryExporter.reset(); + done(); + }); + it('should not affect the behavior of the query', done => { + const query = + "SELECT * FROM user WHERE name = 'test' AND age = 35 AND id = 1"; + const errorQuery = + 'Could not determine the query due to an error in masking or formatting'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].name, 'test'); + assert.strictEqual(res[0].age, 35); + assert.strictEqual(res[0].id, 1); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], errorQuery); + done(); + }); + }); + }); + }); + }); + describe('#maskStatement', () => { + beforeEach(done => { + memoryExporter.reset(); + done(); + }); + + it('should mask query if maskStatement is true', done => { + instrumentation.setConfig({ + maskStatement: true, + }); + const query = 'SELECT 1+1 as solution'; + const maskedQuery = 'SELECT ?+? as solution'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].solution, 2); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], maskedQuery); + done(); + }); + }); + }); + it('should not mask query if maskStatement is false', done => { + instrumentation.setConfig({ + maskStatement: false, + }); + const query = 'SELECT 1+1 as solution'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].solution, 2); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], query); + done(); + }); + }); + }); + }); }); describe('promise API', () => { let instrumentation: MySQL2Instrumentation; @@ -1271,6 +1435,9 @@ describe('mysql2', () => { contextManager = new AsyncHooksContextManager().enable(); context.setGlobalContextManager(contextManager); instrumentation.setTracerProvider(provider); + instrumentation.setConfig({ + maskStatement: false, + }); instrumentation.enable(); connection = await createConnection({ port, From ea64bdcf81404d153dc48b7cf359e6d7c04d1f08 Mon Sep 17 00:00:00 2001 From: gflachs Date: Tue, 25 Feb 2025 13:55:08 +0100 Subject: [PATCH 2/6] Added Changes to Readme --- plugins/node/opentelemetry-instrumentation-mysql2/README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/README.md b/plugins/node/opentelemetry-instrumentation-mysql2/README.md index 52d6d65d60..88a5095fe6 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/README.md +++ b/plugins/node/opentelemetry-instrumentation-mysql2/README.md @@ -48,6 +48,9 @@ You can set the following instrumentation options: | ------- | ---- | ----------- | | `responseHook` | `MySQL2InstrumentationExecutionResponseHook` (function) | Function for adding custom attributes from db response | | `addSqlCommenterCommentToQueries` | `boolean` | If true, adds [sqlcommenter](https://github.com/open-telemetry/opentelemetry-sqlcommenter) specification compliant comment to queries with tracing context (default false). _NOTE: A comment will not be added to queries that already contain `--` or `/* ... */` in them, even if these are not actually part of comments_ | +| `maskStatement` | `boolean` | If true, masks the `db.statement` attribute in spans (default true) with the `maskStatementHook` | +| `maskStatementHook` | `MySQL2InstrumentationMaskStatementHook` (function) | Function for masking the `db.statement` attribute in spans Default: `return query.replace(/\b\d+\b/g, '?').replac(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?');`| + ## Semantic Conventions From 0a2aad89e30e113c3c645fd5be3b6f2f541139fc Mon Sep 17 00:00:00 2001 From: gflachs Date: Tue, 25 Feb 2025 15:17:22 +0100 Subject: [PATCH 3/6] Changed masking, since it wasnt masking properly, when the statement was parameterized. Added tests to confirm this behaviour --- .../src/utils.ts | 12 +++--- .../test/mysql.test.ts | 38 +++++++++++++++++++ 2 files changed, 44 insertions(+), 6 deletions(-) diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts index e3b62c8b3a..3c5450dd9b 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts @@ -114,6 +114,11 @@ export function getDbStatement( ): string { let formattedQuery: string; try { + if (maskStatement) { + formattedQuery = typeof query === 'string' ? query : query.sql; + return maskStatementHook(formattedQuery); + } + if (!format) { formattedQuery = typeof query === 'string' ? query : query.sql; } else if (typeof query === 'string') { @@ -126,12 +131,7 @@ export function getDbStatement( ? format(query.sql, values || (query as QueryOptions).values) : query.sql; } - - return maskStatement - ? values - ? formattedQuery - : maskStatementHook(formattedQuery) - : formattedQuery; + return formattedQuery; } catch (e) { return 'Could not determine the query due to an error in masking or formatting'; } diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts b/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts index 5f888dbac3..018dfe8095 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts @@ -1360,6 +1360,25 @@ describe('mysql2', () => { }); }); }); + it('should return masked query, if values are present', done => { + instrumentation.setConfig({ + maskStatement: true, + }); + const query = 'SELECT ?+? as solution'; + const maskedQuery = 'SELECT ?+? as solution'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, [1, 1], (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].solution, 2); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], maskedQuery); + done(); + }); + }); + }); it('should not mask query if maskStatement is false', done => { instrumentation.setConfig({ maskStatement: false, @@ -1378,6 +1397,25 @@ describe('mysql2', () => { }); }); }); + it('should return query with values, if values are present and maskStatement is false', done => { + instrumentation.setConfig({ + maskStatement: false, + }); + const query = 'SELECT ?+? as solution'; + const queryWithValues = 'SELECT 1+1 as solution'; + const span = provider.getTracer('default').startSpan('test span'); + context.with(trace.setSpan(context.active(), span), () => { + connection.query(query, [1, 1], (err, res: RowDataPacket[]) => { + assert.ifError(err); + assert.ok(res); + assert.strictEqual(res[0].solution, 2); + const spans = memoryExporter.getFinishedSpans(); + assert.strictEqual(spans.length, 1); + assertSpan(spans[0], queryWithValues); + done(); + }); + }); + }); }); }); describe('promise API', () => { From ee9d4dd9693b5a851f83b2b3ff3cbbcedd1f327a Mon Sep 17 00:00:00 2001 From: gflachs Date: Mon, 3 Mar 2025 14:49:15 +0100 Subject: [PATCH 4/6] Readability Adjustments: * Adjusted getDbStatement function, so that its easier to understand * Added comment for defaultMaskingHook, so that its regex and its intent is easier to understand --- .../src/utils.ts | 41 +++++++++++-------- 1 file changed, 25 insertions(+), 16 deletions(-) diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts index 3c5450dd9b..9e797a1e88 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts @@ -112,37 +112,46 @@ export function getDbStatement( maskStatement: boolean = true, maskStatementHook: MySQL2InstrumentationQueryMaskingHook = defaultMaskingHook ): string { - let formattedQuery: string; + const [querySql, queryValues] = + typeof query === 'string' + ? [query, values] + : [query.sql, hasValues(query) ? values || query.values : values]; try { if (maskStatement) { - formattedQuery = typeof query === 'string' ? query : query.sql; - return maskStatementHook(formattedQuery); - } - - if (!format) { - formattedQuery = typeof query === 'string' ? query : query.sql; - } else if (typeof query === 'string') { - formattedQuery = values ? format(query, values) : query; + return maskStatementHook(querySql); + } else if (format && queryValues) { + return format(querySql, queryValues); } else { - // According to https://github.com/mysqljs/mysql#performing-queries - // The values argument will override the values in the option object. - formattedQuery = - values || (query as QueryOptions).values - ? format(query.sql, values || (query as QueryOptions).values) - : query.sql; + return querySql; } - return formattedQuery; } catch (e) { return 'Could not determine the query due to an error in masking or formatting'; } } +/** + * Replaces numeric values and quoted strings in the query with placeholders ('?'). + * + * - `\b\d+\b`: Matches whole numbers (integers) and replaces them with '?'. + * - `(["'])(?:(?=(\\?))\2.)*?\1`: + * - Matches quoted strings (both single `'` and double `"` quotes). + * - Uses a lookahead `(?=(\\?))` to detect an optional backslash without consuming it immediately. + * - Captures the optional backslash `\2` and ensures escaped quotes inside the string are handled correctly. + * - Ensures that only complete quoted strings are replaced with '?'. + * + * This prevents accidental replacement of escaped quotes within strings and ensures that the + * query structure remains intact while masking sensitive data. + */ function defaultMaskingHook(query: string): string { return query .replace(/\b\d+\b/g, '?') .replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?'); } +function hasValues(obj: any): obj is QueryOptions { + return obj && typeof obj === 'object' && 'values' in obj; +} + /** * The span name SHOULD be set to a low cardinality value * representing the statement executed on the database. From 907b1045bb92fe612101674f489dc4d2745e564b Mon Sep 17 00:00:00 2001 From: gflachs Date: Fri, 7 Mar 2025 11:24:06 +0100 Subject: [PATCH 5/6] Added Suggestions for hasValue, run `npm run lint:fix` to fix linting issues --- .../node/opentelemetry-instrumentation-mysql2/src/utils.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts index 9e797a1e88..1889690dc5 100644 --- a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts +++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts @@ -109,7 +109,7 @@ export function getDbStatement( query: string | Query | QueryOptions, format?: formatType, values?: any[], - maskStatement: boolean = true, + maskStatement = true, maskStatementHook: MySQL2InstrumentationQueryMaskingHook = defaultMaskingHook ): string { const [querySql, queryValues] = @@ -148,8 +148,8 @@ function defaultMaskingHook(query: string): string { .replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?'); } -function hasValues(obj: any): obj is QueryOptions { - return obj && typeof obj === 'object' && 'values' in obj; +function hasValues(obj: Query | QueryOptions): obj is QueryOptions { + return 'values' in obj; } /** From 963c343432969028630d6f842b5b92f940ee8265 Mon Sep 17 00:00:00 2001 From: maryliag Date: Wed, 9 Jul 2025 15:30:22 -0400 Subject: [PATCH 6/6] change mask default to false --- packages/instrumentation-mysql2/README.md | 2 +- packages/instrumentation-mysql2/src/types.ts | 2 +- packages/instrumentation-mysql2/src/utils.ts | 2 +- packages/instrumentation-mysql2/test/mysql.test.ts | 13 +------------ 4 files changed, 4 insertions(+), 15 deletions(-) diff --git a/packages/instrumentation-mysql2/README.md b/packages/instrumentation-mysql2/README.md index 88a5095fe6..8ad5c22f67 100644 --- a/packages/instrumentation-mysql2/README.md +++ b/packages/instrumentation-mysql2/README.md @@ -48,7 +48,7 @@ You can set the following instrumentation options: | ------- | ---- | ----------- | | `responseHook` | `MySQL2InstrumentationExecutionResponseHook` (function) | Function for adding custom attributes from db response | | `addSqlCommenterCommentToQueries` | `boolean` | If true, adds [sqlcommenter](https://github.com/open-telemetry/opentelemetry-sqlcommenter) specification compliant comment to queries with tracing context (default false). _NOTE: A comment will not be added to queries that already contain `--` or `/* ... */` in them, even if these are not actually part of comments_ | -| `maskStatement` | `boolean` | If true, masks the `db.statement` attribute in spans (default true) with the `maskStatementHook` | +| `maskStatement` | `boolean` | If true, masks the `db.statement` attribute in spans (default false) with the `maskStatementHook` | | `maskStatementHook` | `MySQL2InstrumentationMaskStatementHook` (function) | Function for masking the `db.statement` attribute in spans Default: `return query.replace(/\b\d+\b/g, '?').replac(/(["'])(?:(?=(\\?))\2.)*?\1/g, '?');`| diff --git a/packages/instrumentation-mysql2/src/types.ts b/packages/instrumentation-mysql2/src/types.ts index dc264f477a..7ecc4a0a55 100644 --- a/packages/instrumentation-mysql2/src/types.ts +++ b/packages/instrumentation-mysql2/src/types.ts @@ -33,7 +33,7 @@ export interface MySQL2InstrumentationConfig extends InstrumentationConfig { /** * If true, the query will be masked before setting it as a span attribute, using the {@link maskStatementHook}. * - * @default true + * @default false * @see maskStatementHook */ maskStatement?: boolean; diff --git a/packages/instrumentation-mysql2/src/utils.ts b/packages/instrumentation-mysql2/src/utils.ts index 1889690dc5..ff62d08ccc 100644 --- a/packages/instrumentation-mysql2/src/utils.ts +++ b/packages/instrumentation-mysql2/src/utils.ts @@ -109,7 +109,7 @@ export function getDbStatement( query: string | Query | QueryOptions, format?: formatType, values?: any[], - maskStatement = true, + maskStatement = false, maskStatementHook: MySQL2InstrumentationQueryMaskingHook = defaultMaskingHook ): string { const [querySql, queryValues] = diff --git a/packages/instrumentation-mysql2/test/mysql.test.ts b/packages/instrumentation-mysql2/test/mysql.test.ts index dc5dcf266f..bfa1a112a6 100644 --- a/packages/instrumentation-mysql2/test/mysql.test.ts +++ b/packages/instrumentation-mysql2/test/mysql.test.ts @@ -156,9 +156,6 @@ describe('mysql2', () => { contextManager = new AsyncLocalStorageContextManager().enable(); context.setGlobalContextManager(contextManager); instrumentation.setTracerProvider(provider); - instrumentation.setConfig({ - maskStatement: false, - }); instrumentation.enable(); connection = createConnection({ port, @@ -1131,7 +1128,6 @@ describe('mysql2', () => { responseHook: (span, responseHookInfo) => { throw new Error('random failure!'); }, - maskStatement: false, }; instrumentation.setConfig(config); }); @@ -1159,7 +1155,6 @@ describe('mysql2', () => { JSON.stringify(responseHookInfo.queryResults) ); }, - maskStatement: false, }; instrumentation.setConfig(config); }); @@ -1389,10 +1384,7 @@ describe('mysql2', () => { }); }); }); - it('should not mask query if maskStatement is false', done => { - instrumentation.setConfig({ - maskStatement: false, - }); + it('should not mask query if maskStatement is false (default)', done => { const query = 'SELECT 1+1 as solution'; const span = provider.getTracer('default').startSpan('test span'); context.with(trace.setSpan(context.active(), span), () => { @@ -1499,9 +1491,6 @@ describe('mysql2', () => { contextManager = new AsyncLocalStorageContextManager().enable(); context.setGlobalContextManager(contextManager); instrumentation.setTracerProvider(provider); - instrumentation.setConfig({ - maskStatement: false, - }); instrumentation.enable(); connection = await createConnection({ port,