diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts
index db6d4f2329..de1e50f70f 100644
--- a/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts
+++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/instrumentation.ts
@@ -23,7 +23,12 @@ import {
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
 import type * as mysqlTypes from 'mysql2';
 import { MySQL2InstrumentationConfig } from './types';
-import { getConnectionAttributes, getDbStatement, getSpanName, once } from './utils';
+import {
+  getConnectionAttributes,
+  getDbStatement,
+  getSpanName,
+  once,
+} from './utils';
 import { VERSION } from './version';
 
 type formatType = typeof mysqlTypes.format;
@@ -48,7 +53,8 @@ export class MySQLInstrumentation extends InstrumentationBase<
         (moduleExports: any, moduleVersion) => {
           api.diag.debug(`Patching mysql@${moduleVersion}`);
 
-          const ConnectionPrototype: mysqlTypes.Connection = moduleExports.Connection.prototype;
+          const ConnectionPrototype: mysqlTypes.Connection =
+            moduleExports.Connection.prototype;
           api.diag.debug('Patching Connection.prototype.query');
           if (isWrapped(ConnectionPrototype.query)) {
             this._unwrap(ConnectionPrototype, 'query');
@@ -63,16 +69,15 @@ export class MySQLInstrumentation extends InstrumentationBase<
         },
         (moduleExports: any) => {
           if (moduleExports === undefined) return;
-          const ConnectionPrototype: mysqlTypes.Connection = moduleExports.Connection.prototype;
+          const ConnectionPrototype: mysqlTypes.Connection =
+            moduleExports.Connection.prototype;
           this._unwrap(ConnectionPrototype, 'query');
         }
       ),
     ];
   }
 
-  private _patchQuery(
-    format: formatType
-  ) {
+  private _patchQuery(format: formatType) {
     return (originalQuery: Function): Function => {
       const thisPlugin = this;
       api.diag.debug('MySQLInstrumentation: patched mysql query');
@@ -95,7 +100,11 @@ export class MySQLInstrumentation extends InstrumentationBase<
           attributes: {
             ...MySQLInstrumentation.COMMON_ATTRIBUTES,
             ...getConnectionAttributes(this.config),
-            [SemanticAttributes.DB_STATEMENT]: getDbStatement(query, format, values),
+            [SemanticAttributes.DB_STATEMENT]: getDbStatement(
+              query,
+              format,
+              values
+            ),
           },
         });
         const endSpan = once((err?: any) => {
@@ -110,7 +119,11 @@ export class MySQLInstrumentation extends InstrumentationBase<
 
         if (arguments.length === 1) {
           if (typeof (query as any).onResult === 'function') {
-            thisPlugin._wrap((query as any), 'onResult', thisPlugin._patchCallbackQuery(endSpan));
+            thisPlugin._wrap(
+              query as any,
+              'onResult',
+              thisPlugin._patchCallbackQuery(endSpan)
+            );
           }
 
           const streamableQuery: mysqlTypes.Query = originalQuery.apply(
@@ -131,9 +144,17 @@ export class MySQLInstrumentation extends InstrumentationBase<
         }
 
         if (typeof arguments[1] === 'function') {
-          thisPlugin._wrap(arguments, 1, thisPlugin._patchCallbackQuery(endSpan));
+          thisPlugin._wrap(
+            arguments,
+            1,
+            thisPlugin._patchCallbackQuery(endSpan)
+          );
         } else if (typeof arguments[2] === 'function') {
-          thisPlugin._wrap(arguments, 2, thisPlugin._patchCallbackQuery(endSpan));
+          thisPlugin._wrap(
+            arguments,
+            2,
+            thisPlugin._patchCallbackQuery(endSpan)
+          );
         }
 
         return originalQuery.apply(this, arguments);
diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts
index 9526e98a98..b6ab662be2 100644
--- a/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts
+++ b/plugins/node/opentelemetry-instrumentation-mysql2/src/utils.ts
@@ -16,27 +16,21 @@
 
 import { SpanAttributes } from '@opentelemetry/api';
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
-import type {
-  Query,
-  QueryOptions,
-} from 'mysql2';
-
+import type { Query, QueryOptions } from 'mysql2';
 
 interface Config {
-  host?: string,
-  port?: number,
-  database?: string,
-  user?: string,
-  connectionConfig?: Config,
+  host?: string;
+  port?: number;
+  database?: string;
+  user?: string;
+  connectionConfig?: Config;
 }
 /**
  * Get an SpanAttributes map from a mysql connection config object
  *
  * @param config ConnectionConfig
  */
-export function getConnectionAttributes(
-  config: Config
-): SpanAttributes {
+export function getConnectionAttributes(config: Config): SpanAttributes {
   const { host, port, database, user } = getConfig(config);
 
   return {
@@ -115,6 +109,7 @@ export const once = (fn: Function) => {
   let called = false;
   return (...args: unknown[]) => {
     if (called) return;
+    called = true;
     return fn(...args);
   };
 };
diff --git a/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts b/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts
index 78e83ecfc2..5c254fef5e 100644
--- a/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts
+++ b/plugins/node/opentelemetry-instrumentation-mysql2/test/mysql.test.ts
@@ -40,8 +40,8 @@ instrumentation.disable();
 import * as mysqlTypes from 'mysql2';
 
 interface Result extends mysqlTypes.RowDataPacket {
-  solution: number,
-};
+  solution: number;
+}
 
 describe('mysql@2.x', () => {
   let contextManager: AsyncHooksContextManager;
@@ -102,13 +102,13 @@ describe('mysql@2.x', () => {
     poolCluster = mysqlTypes.createPoolCluster();
     // the implementation actually accepts ConnectionConfig as well,
     // but the types do not reflect that
-    poolCluster.add('name', ({
+    poolCluster.add('name', {
       port,
       user,
       host,
       password,
       database,
-    } as mysqlTypes.PoolClusterOptions));
+    } as mysqlTypes.PoolClusterOptions);
   });
 
   afterEach(done => {
@@ -201,15 +201,18 @@ describe('mysql@2.x', () => {
       const span = provider.getTracer('default').startSpan('test span');
       context.with(trace.setSpan(context.active(), span), () => {
         const sql = 'SELECT 1+? as solution';
-        connection.query({ sql, values: [1] }, (err, res: mysqlTypes.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], sql, [1]);
-          done();
-        });
+        connection.query(
+          { sql, values: [1] },
+          (err, res: mysqlTypes.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], sql, [1]);
+            done();
+          }
+        );
       });
     });
 
@@ -217,15 +220,19 @@ describe('mysql@2.x', () => {
       const span = provider.getTracer('default').startSpan('test span');
       context.with(trace.setSpan(context.active(), span), () => {
         const sql = 'SELECT 1+? as solution';
-        connection.query({ sql }, [1], (err, res: mysqlTypes.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], sql, [1]);
-          done();
-        });
+        connection.query(
+          { sql },
+          [1],
+          (err, res: mysqlTypes.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], sql, [1]);
+            done();
+          }
+        );
       });
     });
 
@@ -361,15 +368,18 @@ describe('mysql@2.x', () => {
       const span = provider.getTracer('default').startSpan('test span');
       context.with(trace.setSpan(context.active(), span), () => {
         const sql = 'SELECT 1+? as solution';
-        pool.query({ sql, values: [1] }, (err, res: mysqlTypes.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], sql, [1]);
-          done();
-        });
+        pool.query(
+          { sql, values: [1] },
+          (err, res: mysqlTypes.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], sql, [1]);
+            done();
+          }
+        );
       });
     });
 
@@ -468,15 +478,18 @@ describe('mysql@2.x', () => {
         const span = provider.getTracer('default').startSpan('test span');
         context.with(trace.setSpan(context.active(), span), () => {
           const sql = 'SELECT 1+1 as solution';
-          poolClusterConnection.query(sql, (err, res: mysqlTypes.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], sql);
-            done();
-          });
+          poolClusterConnection.query(
+            sql,
+            (err, res: mysqlTypes.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], sql);
+              done();
+            }
+          );
         });
       });
     });
@@ -487,15 +500,18 @@ describe('mysql@2.x', () => {
         const span = provider.getTracer('default').startSpan('test span');
         context.with(trace.setSpan(context.active(), span), () => {
           const sql = 'SELECT 1+? as solution';
-          poolClusterConnection.query({ sql, values: [1] }, (err, res: mysqlTypes.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], sql, [1]);
-            done();
-          });
+          poolClusterConnection.query(
+            { sql, values: [1] },
+            (err, res: mysqlTypes.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], sql, [1]);
+              done();
+            }
+          );
         });
       });
     });
@@ -506,15 +522,19 @@ describe('mysql@2.x', () => {
         const span = provider.getTracer('default').startSpan('test span');
         context.with(trace.setSpan(context.active(), span), () => {
           const sql = 'SELECT 1+? as solution';
-          poolClusterConnection.query({ sql }, [1], (err, res: mysqlTypes.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], sql, [1]);
-            done();
-          });
+          poolClusterConnection.query(
+            { sql },
+            [1],
+            (err, res: mysqlTypes.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], sql, [1]);
+              done();
+            }
+          );
         });
       });
     });
@@ -525,15 +545,19 @@ describe('mysql@2.x', () => {
         const span = provider.getTracer('default').startSpan('test span');
         context.with(trace.setSpan(context.active(), span), () => {
           const sql = 'SELECT ? as solution';
-          poolClusterConnection.query(sql, [1], (err, res: mysqlTypes.RowDataPacket[]) => {
-            assert.ifError(err);
-            assert.ok(res);
-            assert.strictEqual(res[0].solution, 1);
-            const spans = memoryExporter.getFinishedSpans();
-            assert.strictEqual(spans.length, 1);
-            assertSpan(spans[0], sql, [1]);
-            done();
-          });
+          poolClusterConnection.query(
+            sql,
+            [1],
+            (err, res: mysqlTypes.RowDataPacket[]) => {
+              assert.ifError(err);
+              assert.ok(res);
+              assert.strictEqual(res[0].solution, 1);
+              const spans = memoryExporter.getFinishedSpans();
+              assert.strictEqual(spans.length, 1);
+              assertSpan(spans[0], sql, [1]);
+              done();
+            }
+          );
         });
       });
     });
@@ -544,15 +568,19 @@ describe('mysql@2.x', () => {
         const span = provider.getTracer('default').startSpan('test span');
         context.with(trace.setSpan(context.active(), span), () => {
           const sql = 'SELECT ? as solution';
-          poolClusterConnection.query(sql, 1, (err, res: mysqlTypes.RowDataPacket[]) => {
-            assert.ifError(err);
-            assert.ok(res);
-            assert.strictEqual(res[0].solution, 1);
-            const spans = memoryExporter.getFinishedSpans();
-            assert.strictEqual(spans.length, 1);
-            assertSpan(spans[0], sql, [1]);
-            done();
-          });
+          poolClusterConnection.query(
+            sql,
+            1,
+            (err, res: mysqlTypes.RowDataPacket[]) => {
+              assert.ifError(err);
+              assert.ok(res);
+              assert.strictEqual(res[0].solution, 1);
+              const spans = memoryExporter.getFinishedSpans();
+              assert.strictEqual(spans.length, 1);
+              assertSpan(spans[0], sql, [1]);
+              done();
+            }
+          );
         });
       });
     });