opencons 0.1.0

package/src/drivers/drizzle.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const { traceDbCall, truncateQuery } = require('./record');
+const { extractTableFromSql } = require('./db-language');
+
+let patched = false;
+
+/**
+ * @param {Function} original
+ * @param {'node-postgres' | 'mysql2'} dialect
+ */
+function wrapExecute(original, dialect) {
+  return async function OpenconsDrizzleExecute(placeholderValues = {}) {
+    const queryText =
+      this.rawQueryConfig?.text ||
+      this.rawQuery?.sql ||
+      this.query?.sql ||
+      this.queryString ||
+      '';
+
+    return traceDbCall(() => original.call(this, placeholderValues), {
+      driver: 'drizzle',
+      operation: dialect === 'mysql2' ? 'execute' : 'query',
+      query: truncateQuery(queryText),
+      params: this.params,
+      collection: extractTableFromSql(queryText),
+    });
+  };
+}
+
+/**
+ * @param {string} modulePath
+ * @param {string} className
+ * @param {'node-postgres' | 'mysql2'} dialect
+ */
+function patchPreparedQuery(modulePath, className, dialect) {
+  let session;
+
+  try {
+    const { createRequire } = require('module');
+    const path = require('path');
+    const hostRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    session = hostRequire(modulePath);
+  } catch {
+    try {
+      session = require(modulePath);
+    } catch {
+      return false;
+    }
+  }
+
+  const PreparedQuery = session[className];
+
+  if (!PreparedQuery?.prototype?.execute || PreparedQuery.prototype.execute.__openconsWrapped) {
+    return false;
+  }
+
+  const original = PreparedQuery.prototype.execute;
+  PreparedQuery.prototype.execute = wrapExecute(original, dialect);
+  PreparedQuery.prototype.execute.__openconsWrapped = true;
+
+  return true;
+}
+
+function patchDrizzle() {
+  if (patched) return [];
+
+  const backends = [];
+
+  if (patchPreparedQuery('drizzle-orm/node-postgres/session', 'NodePgPreparedQuery', 'node-postgres')) {
+    backends.push('node-postgres');
+  }
+
+  if (patchPreparedQuery('drizzle-orm/mysql2/session', 'MySql2PreparedQuery', 'mysql2')) {
+    backends.push('mysql2');
+  }
+
+  if (backends.length) {
+    patched = true;
+  }
+
+  return backends;
+}
+
+module.exports = {
+  patchDrizzle,
+};

package/src/drivers/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { resolveDriverConfig } = require('./detect');
+const { patchPg } = require('./pg');
+const { patchMongoose } = require('./mongoose');
+const { patchPrisma } = require('./prisma');
+const { patchMysql2 } = require('./mysql2');
+const { patchDrizzle } = require('./drizzle');
+
+let installed = false;
+
+/**
+ * @param {Partial<Record<'mongoose' | 'pg' | 'prisma' | 'mysql2' | 'drizzle', boolean>>} [config]
+ */
+function installDrivers(config = {}) {
+  if (installed) return { patched: [] };
+
+  const resolved = resolveDriverConfig(config);
+  const patched = [];
+
+  if (resolved.drizzle) {
+    const backends = patchDrizzle();
+    if (backends.length) patched.push(`drizzle (${backends.join(', ')})`);
+  }
+
+  if (resolved.pg && patchPg()) patched.push('pg');
+  if (resolved.mongoose && patchMongoose()) patched.push('mongoose');
+  if (resolved.prisma && patchPrisma()) patched.push('prisma');
+  if (resolved.mysql2 && patchMysql2()) patched.push('mysql2');
+
+  installed = patched.length > 0;
+
+  if (patched.length) {
+    const { logger } = require('../lib/logger');
+    logger.info(`Database drivers patched: ${patched.join(', ')}`);
+  }
+
+  return { patched, resolved };
+}
+
+module.exports = {
+  installDrivers,
+};

package/src/drivers/mongoose.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const { traceDbCall, truncateQuery, safeParams } = require('./record');
+
+let patched = false;
+
+/**
+ * @param {import('mongoose').Query} query
+ */
+function describeMongooseQuery(query) {
+  const op = query.op || 'query';
+  const collection = query.model?.collection?.name || query.mongooseCollection?.name;
+  const filter = typeof query.getFilter === 'function' ? query.getFilter() : {};
+  const update =
+    typeof query.getUpdate === 'function' ? query.getUpdate() : undefined;
+
+  let text = `${op} ${JSON.stringify(filter)}`;
+  if (update) {
+    text += ` update=${JSON.stringify(update)}`;
+  }
+
+  return {
+    operation: op,
+    collection,
+    query: truncateQuery(text),
+    params: safeParams(filter),
+  };
+}
+
+function patchMongoose() {
+  if (patched) return false;
+
+  let mongoose;
+
+  try {
+    const { createRequire } = require('module');
+    const path = require('path');
+    const hostRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    mongoose = hostRequire('mongoose');
+  } catch {
+    try {
+      mongoose = require('mongoose');
+    } catch {
+      return false;
+    }
+  }
+
+  if (!mongoose.Query?.prototype?.exec || mongoose.Query.prototype.exec.__openconsWrapped) {
+    return false;
+  }
+
+  const originalExec = mongoose.Query.prototype.exec;
+
+  mongoose.Query.prototype.exec = function OpenconsMongooseExec(...args) {
+    const meta = describeMongooseQuery(this);
+    return traceDbCall(() => originalExec.apply(this, args), {
+      driver: 'mongoose',
+      ...meta,
+    });
+  };
+
+  mongoose.Query.prototype.exec.__openconsWrapped = true;
+
+  if (mongoose.Aggregate?.prototype?.exec && !mongoose.Aggregate.prototype.exec.__openconsWrapped) {
+    const originalAggregateExec = mongoose.Aggregate.prototype.exec;
+
+    mongoose.Aggregate.prototype.exec = function OpenconsAggregateExec(...args) {
+      const collection = this._model?.collection?.name;
+      const pipeline = this.pipeline();
+
+      return traceDbCall(() => originalAggregateExec.apply(this, args), {
+        driver: 'mongoose',
+        operation: 'aggregate',
+        collection,
+        query: truncateQuery(`aggregate ${JSON.stringify(pipeline)}`),
+        params: safeParams(pipeline),
+      });
+    };
+
+    mongoose.Aggregate.prototype.exec.__openconsWrapped = true;
+  }
+
+  patched = true;
+  return true;
+}
+
+module.exports = {
+  patchMongoose,
+};

package/src/drivers/mysql2.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const { traceDbCall, truncateQuery } = require('./record');
+
+let patched = false;
+
+/**
+ * @param {Function} original
+ * @param {string} operation
+ */
+function wrapMysqlMethod(original, operation) {
+  return function OpenconsMysql(...args) {
+    const sql = typeof args[0] === 'string' ? args[0] : args[0]?.sql;
+    const params = typeof args[0] === 'object' && args[0]?.sql ? args[0].values : args[1];
+    const callback = typeof args[args.length - 1] === 'function' ? args[args.length - 1] : null;
+
+    if (callback) {
+      const start = performance.now();
+      const wrapped = args.slice(0, -1);
+
+      wrapped.push((err, result) => {
+        const { recordDbQuery } = require('./record');
+
+        if (err) {
+          recordDbQuery({
+            driver: 'mysql2',
+            operation,
+            query: truncateQuery(sql || ''),
+            params,
+            duration_ms: Math.round((performance.now() - start) * 10) / 10,
+            error: err.message,
+          });
+        } else {
+          recordDbQuery({
+            driver: 'mysql2',
+            operation,
+            query: truncateQuery(sql || ''),
+            params,
+            rows: Array.isArray(result) ? result[0]?.affectedRows ?? result[0]?.length : result?.affectedRows,
+            duration_ms: Math.round((performance.now() - start) * 10) / 10,
+          });
+        }
+
+        callback(err, result);
+      });
+
+      return original.apply(this, wrapped);
+    }
+
+    const result = original.apply(this, args);
+
+    if (result && typeof result.then === 'function') {
+      return traceDbCall(() => result, {
+        driver: 'mysql2',
+        operation,
+        query: truncateQuery(sql || ''),
+        params,
+      });
+    }
+
+    return result;
+  };
+}
+
+/**
+ * @param {object} target
+ */
+function patchConnectionLike(target) {
+  if (!target?.prototype) return;
+
+  if (target.prototype.query && !target.prototype.query.__openconsWrapped) {
+    target.prototype.query = wrapMysqlMethod(target.prototype.query, 'query');
+    target.prototype.query.__openconsWrapped = true;
+  }
+
+  if (target.prototype.execute && !target.prototype.execute.__openconsWrapped) {
+    target.prototype.execute = wrapMysqlMethod(target.prototype.execute, 'execute');
+    target.prototype.execute.__openconsWrapped = true;
+  }
+}
+
+function patchMysql2() {
+  if (patched) return false;
+
+  let mysql2;
+
+  try {
+    const { createRequire } = require('module');
+    const path = require('path');
+    const hostRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    mysql2 = hostRequire('mysql2');
+  } catch {
+    try {
+      mysql2 = require('mysql2');
+    } catch {
+      return false;
+    }
+  }
+
+  patchConnectionLike(mysql2);
+  if (mysql2.createPool) {
+    const originalCreatePool = mysql2.createPool.bind(mysql2);
+    mysql2.createPool = function OpenconsCreatePool(...args) {
+      const pool = originalCreatePool(...args);
+      patchConnectionLike(pool.constructor);
+      return pool;
+    };
+  }
+
+  patched = true;
+  return true;
+}
+
+module.exports = {
+  patchMysql2,
+};

package/src/drivers/pg.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const { traceDbCall, truncateQuery } = require('./record');
+
+let patched = false;
+
+/**
+ * @param {unknown[]} args
+ */
+function parsePgQueryArgs(args) {
+  if (!args.length) return { text: '', values: undefined };
+
+  if (typeof args[0] === 'string') {
+    return {
+      text: args[0],
+      values: args[1],
+    };
+  }
+
+  if (typeof args[0] === 'object' && args[0]) {
+    return {
+      text: args[0].text || args[0].name || '',
+      values: args[0].values,
+    };
+  }
+
+  return { text: '', values: undefined };
+}
+
+/**
+ * @param {Function} original
+ */
+function wrapQuery(original) {
+  return function OpenconsPgQuery(...args) {
+    const { text, values } = parsePgQueryArgs(args);
+    const start = performance.now();
+    const lastArg = args[args.length - 1];
+
+    if (typeof lastArg === 'function') {
+      const callback = lastArg;
+      const wrappedArgs = args.slice(0, -1);
+
+      wrappedArgs.push((err, result) => {
+        const { recordDbQuery } = require('./record');
+
+        if (err) {
+          recordDbQuery({
+            driver: 'pg',
+            operation: 'query',
+            query: truncateQuery(text),
+            params: values,
+            duration_ms: Math.round((performance.now() - start) * 10) / 10,
+            error: err.message,
+          });
+        } else {
+          recordDbQuery({
+            driver: 'pg',
+            operation: 'query',
+            query: truncateQuery(text),
+            params: values,
+            rows: result?.rowCount,
+            duration_ms: Math.round((performance.now() - start) * 10) / 10,
+          });
+        }
+
+        callback(err, result);
+      });
+
+      return original.apply(this, wrappedArgs);
+    }
+
+    const result = original.apply(this, args);
+
+    if (result && typeof result.then === 'function') {
+      return traceDbCall(() => result, {
+        driver: 'pg',
+        operation: 'query',
+        query: truncateQuery(text),
+        params: values,
+      });
+    }
+
+    return result;
+  };
+}
+
+/**
+ * @param {object} client
+ */
+function patchPgClientPrototype(client) {
+  if (!client?.prototype?.query || client.prototype.query.__openconsWrapped) {
+    return;
+  }
+
+  const original = client.prototype.query;
+  client.prototype.query = wrapQuery(original);
+  client.prototype.query.__openconsWrapped = true;
+}
+
+function patchPg() {
+  if (patched) return false;
+
+  let pg;
+
+  try {
+    const { createRequire } = require('module');
+    const path = require('path');
+    const hostRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    pg = hostRequire('pg');
+  } catch {
+    try {
+      pg = require('pg');
+    } catch {
+      return false;
+    }
+  }
+
+  patchPgClientPrototype(pg.Client);
+
+  if (pg.Pool?.prototype) {
+    patchPgClientPrototype(pg.Pool);
+  }
+
+  patched = true;
+  return true;
+}
+
+module.exports = {
+  patchPg,
+};

package/src/drivers/prisma.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const { traceDbCall, truncateQuery, safeParams } = require('./record');
+
+/** @type {WeakSet<object>} */
+const patchedClients = new WeakSet();
+
+/**
+ * @param {object} client
+ */
+function patchPrismaClient(client) {
+  if (!client || patchedClients.has(client)) return client;
+
+  if (typeof client.$use !== 'function') {
+    return client;
+  }
+
+  client.$use(async (params, next) => {
+    const query = `${params.model || 'raw'}.${params.action}`;
+    const start = performance.now();
+
+    try {
+      const result = await next(params);
+      const { recordDbQuery } = require('./record');
+
+      recordDbQuery({
+        driver: 'prisma',
+        operation: params.action,
+        collection: params.model,
+        query: truncateQuery(query),
+        params: safeParams(params.args),
+        rows: Array.isArray(result) ? result.length : result == null ? 0 : 1,
+        duration_ms: Math.round((performance.now() - start) * 10) / 10,
+      });
+
+      return result;
+    } catch (err) {
+      const { recordDbQuery } = require('./record');
+
+      recordDbQuery({
+        driver: 'prisma',
+        operation: params.action,
+        collection: params.model,
+        query: truncateQuery(query),
+        params: safeParams(params.args),
+        duration_ms: Math.round((performance.now() - start) * 10) / 10,
+        error: err && err.message ? err.message : String(err),
+      });
+
+      throw err;
+    }
+  });
+
+  patchedClients.add(client);
+  return client;
+}
+
+let prismaModulePatched = false;
+
+function patchPrisma() {
+  if (prismaModulePatched) return false;
+
+  let PrismaClient;
+
+  try {
+    const { createRequire } = require('module');
+    const path = require('path');
+    const hostRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    ({ PrismaClient } = hostRequire('@prisma/client'));
+  } catch {
+    try {
+      ({ PrismaClient } = require('@prisma/client'));
+    } catch {
+      return false;
+    }
+  }
+
+  if (!PrismaClient?.prototype || PrismaClient.prototype.__openconsWrapped) {
+    return false;
+  }
+
+  const Original = PrismaClient;
+
+  const WrappedPrismaClient = function OpenconsPrismaClient(...args) {
+    const client = new Original(...args);
+    return patchPrismaClient(client);
+  };
+
+  WrappedPrismaClient.prototype = Original.prototype;
+  Object.setPrototypeOf(WrappedPrismaClient, Original);
+  Object.assign(WrappedPrismaClient, Original);
+
+  try {
+    const clientModule = require('@prisma/client');
+    clientModule.PrismaClient = WrappedPrismaClient;
+  } catch {
+    // Host may load from a different path; constructor hook still helps new imports.
+  }
+
+  PrismaClient.prototype.constructor = WrappedPrismaClient;
+  PrismaClient.prototype.__openconsWrapped = true;
+  prismaModulePatched = true;
+  return true;
+}
+
+module.exports = {
+  patchPrisma,
+  patchPrismaClient,
+};