@devskin/agent 1.0.0 → 1.0.2

package/src/agent.ts

@@ -22,6 +22,7 @@ export class Agent {
       sampleRate: 1.0,
       instrumentHttp: true,
       instrumentExpress: true,
+      instrumentDatabase: true,
       batchSize: 100,
       flushInterval: 10000, // 10 seconds
       debug: false,
@@ -41,6 +42,7 @@ export class Agent {
       this.config.serverUrl,
       this.config.apiKey,
       this.config.serviceName,
+      this.config.applicationId,
       this.config.debug
     );
   }
@@ -71,6 +73,10 @@ export class Agent {
       await this.initHttpInstrumentation();
     }
 
+    if (this.config.instrumentDatabase) {
+      await this.initDatabaseInstrumentation();
+    }
+
     if (this.config.debug) {
       console.log('[DevSkin Agent] Agent started successfully');
     }
@@ -111,6 +117,38 @@ export class Agent {
     }
   }
 
+  /**
+   * Initialize Database instrumentation
+   */
+  private async initDatabaseInstrumentation(): Promise<void> {
+    try {
+      // SQL Databases - use require() instead of import() to ensure synchronous loading
+      const { instrumentMysql } = require('./instrumentation/mysql');
+      instrumentMysql(this);
+
+      const { instrumentPostgres } = require('./instrumentation/postgres');
+      instrumentPostgres(this);
+
+      // NoSQL Databases
+      const { instrumentMongoDB } = require('./instrumentation/mongodb');
+      instrumentMongoDB(this);
+
+      const { instrumentRedis } = require('./instrumentation/redis');
+      instrumentRedis(this);
+
+      const { instrumentElasticsearch } = require('./instrumentation/elasticsearch');
+      instrumentElasticsearch(this);
+
+      if (this.config.debug) {
+        console.log('[DevSkin Agent] Database instrumentation initialized');
+      }
+    } catch (error: any) {
+      if (this.config.debug) {
+        console.error('[DevSkin Agent] Failed to initialize Database instrumentation:', error.message);
+      }
+    }
+  }
+
   /**
    * Send service metadata
    */

package/src/api-client.ts

@@ -8,20 +8,28 @@ export class ApiClient {
   private client: AxiosInstance;
   private apiKey: string;
   private serviceName: string;
+  private applicationId?: string;
   private debug: boolean;
 
-  constructor(serverUrl: string, apiKey: string, serviceName: string, debug = false) {
+  constructor(serverUrl: string, apiKey: string, serviceName: string, applicationId?: string, debug = false) {
     this.apiKey = apiKey;
     this.serviceName = serviceName;
+    this.applicationId = applicationId;
     this.debug = debug;
 
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'X-DevSkin-API-Key': apiKey,
+    };
+
+    if (applicationId) {
+      headers['X-DevSkin-Application-Id'] = applicationId;
+    }
+
     this.client = axios.create({
       baseURL: serverUrl,
       timeout: 30000,
-      headers: {
-        'Content-Type': 'application/json',
-        'X-DevSkin-API-Key': apiKey,
-      },
+      headers,
     });
   }
 

package/src/index.ts

@@ -8,6 +8,7 @@
  * const agent = init({
  *   serverUrl: 'https://api-monitoring.devskin.com',
  *   apiKey: 'your-api-key',
+ *   applicationId: 'your-application-id',
  *   serviceName: 'my-service',
  *   serviceVersion: '1.0.0',
  *   environment: 'production',
@@ -25,6 +26,8 @@ export * from './api-client';
 export * from './utils/context';
 export * from './utils/id-generator';
 export { expressMiddleware, expressErrorHandler } from './instrumentation/express';
+export { instrumentMysql } from './instrumentation/mysql';
+export { instrumentPostgres } from './instrumentation/postgres';
 
 // Re-export commonly used functions
 export { init, getAgent, startAgent, stopAgent } from './agent';

package/src/instrumentation/elasticsearch.ts

@@ -0,0 +1,98 @@
+import { Agent } from '../agent';
+import { SpanBuilder } from '../span';
+import { SpanKind, SpanStatus } from '../types';
+
+/**
+ * Instrument Elasticsearch client for database monitoring
+ */
+export function instrumentElasticsearch(agent: Agent): void {
+  try {
+    let elasticsearch: any;
+    try {
+      elasticsearch = require('@elastic/elasticsearch');
+    } catch {
+      return;
+    }
+
+    const config = agent.getConfig();
+    const originalTransport = elasticsearch.Client.prototype.transport;
+
+    // Override transport.request to intercept all requests
+    Object.defineProperty(elasticsearch.Client.prototype, 'transport', {
+      get() {
+        return originalTransport;
+      },
+      set(transport: any) {
+        if (transport && transport.request) {
+          const originalRequest = transport.request.bind(transport);
+
+          transport.request = function (params: any, options: any) {
+            if (!agent.shouldSample()) {
+              return originalRequest(params, options);
+            }
+
+            const method = params?.method || 'GET';
+            const path = params?.path || '/';
+            const body = params?.body;
+
+            // Extract operation from path
+            const operation = path.split('/')[1] || 'unknown';
+
+            const span = new SpanBuilder(
+              `elasticsearch.${operation}`,
+              SpanKind.CLIENT,
+              config.serviceName!,
+              config.serviceVersion,
+              config.environment,
+              agent
+            );
+
+            span.setAttributes({
+              'db.system': 'elasticsearch',
+              'db.operation': `${method} ${path}`,
+              'db.statement': body ? JSON.stringify(body).substring(0, 1000) : '',
+              'http.method': method,
+              'http.url': path,
+            });
+
+            span.setAttribute('span.kind', 'client');
+
+            const result = originalRequest(params, options);
+
+            if (result && typeof result.then === 'function') {
+              return result
+                .then((res: any) => {
+                  span.setStatus(SpanStatus.OK);
+                  if (res?.body?.hits?.total) {
+                    span.setAttribute('db.rows_affected', res.body.hits.total.value || res.body.hits.total);
+                  }
+                  span.end();
+                  return res;
+                })
+                .catch((err: any) => {
+                  span.setStatus(SpanStatus.ERROR, err.message);
+                  span.setAttribute('error', true);
+                  span.setAttribute('error.message', err.message);
+                  span.end();
+                  throw err;
+                });
+            }
+
+            span.end();
+            return result;
+          };
+        }
+
+        originalTransport.call(this, transport);
+      },
+    });
+
+    if (config.debug) {
+      console.log('[DevSkin Agent] Elasticsearch instrumentation enabled');
+    }
+  } catch (error: any) {
+    if (agent.getConfig().debug) {
+      console.error('[DevSkin Agent] Failed to instrument Elasticsearch:', error.message);
+    }
+  }
+}

package/src/instrumentation/mongodb.ts

@@ -0,0 +1,150 @@
+import { Agent } from '../agent';
+import { SpanBuilder } from '../span';
+import { SpanKind, SpanStatus } from '../types';
+
+/**
+ * Instrument MongoDB driver for database monitoring
+ */
+export function instrumentMongoDB(agent: Agent): void {
+  try {
+    let mongodb: any;
+    try {
+      mongodb = require('mongodb');
+    } catch {
+      // mongodb not installed
+      return;
+    }
+
+    const config = agent.getConfig();
+
+    // Patch Collection.prototype methods
+    const methods = [
+      'find', 'findOne', 'insertOne', 'insertMany',
+      'updateOne', 'updateMany', 'deleteOne', 'deleteMany',
+      'aggregate', 'countDocuments', 'distinct', 'findOneAndUpdate',
+      'findOneAndDelete', 'findOneAndReplace', 'replaceOne', 'bulkWrite'
+    ];
+
+    for (const method of methods) {
+      const original = mongodb.Collection.prototype[method];
+      if (!original) continue;
+
+      mongodb.Collection.prototype[method] = function (...args: any[]) {
+        if (!agent.shouldSample()) {
+          return original.apply(this, args);
+        }
+
+        const collectionName = this.collectionName;
+        const dbName = this.s?.db?.databaseName || this.namespace?.db || 'unknown';
+        const connectionString = this.s?.db?.s?.client?.s?.url || '';
+
+        // Extract host and port from connection
+        let host = 'localhost';
+        let port = 27017;
+        try {
+          const url = new URL(connectionString);
+          host = url.hostname || 'localhost';
+          port = parseInt(url.port) || 27017;
+        } catch {}
+
+        // Create span
+        const span = new SpanBuilder(
+          `mongodb.${method}`,
+          SpanKind.CLIENT,
+          config.serviceName!,
+          config.serviceVersion,
+          config.environment,
+          agent
+        );
+
+        // Set MongoDB attributes following OpenTelemetry semantic conventions
+        span.setAttributes({
+          'db.system': 'mongodb',
+          'db.name': dbName,
+          'db.mongodb.collection': collectionName,
+          'db.operation': method,
+          'net.peer.name': host,
+          'net.peer.port': port,
+          'db.connection_string': connectionString.replace(/\/\/[^@]*@/, '//***@'), // Hide credentials
+        });
+
+        // Add query details if available
+        if (args[0]) {
+          if (typeof args[0] === 'object') {
+            span.setAttribute('db.statement', JSON.stringify(args[0]).substring(0, 1000));
+          }
+        }
+
+        span.setAttribute('span.kind', 'client');
+
+        const startTime = Date.now();
+
+        // Execute original method
+        const result = original.apply(this, args);
+
+        // Handle promise-based operations
+        if (result && typeof result.then === 'function') {
+          return result
+            .then((res: any) => {
+              span.setStatus(SpanStatus.OK);
+
+              // Add result metadata
+              if (res) {
+                if (res.insertedCount !== undefined) {
+                  span.setAttribute('db.rows_affected', res.insertedCount);
+                } else if (res.modifiedCount !== undefined) {
+                  span.setAttribute('db.rows_affected', res.modifiedCount);
+                } else if (res.deletedCount !== undefined) {
+                  span.setAttribute('db.rows_affected', res.deletedCount);
+                } else if (Array.isArray(res)) {
+                  span.setAttribute('db.rows_affected', res.length);
+                }
+              }
+
+              span.end();
+              return res;
+            })
+            .catch((err: any) => {
+              span.setStatus(SpanStatus.ERROR, err.message);
+              span.setAttribute('error', true);
+              span.setAttribute('error.message', err.message);
+              span.setAttribute('error.type', err.name || 'Error');
+              span.end();
+              throw err;
+            });
+        }
+
+        // Handle cursor-based operations (find, aggregate)
+        if (result && typeof result.toArray === 'function') {
+          const originalToArray = result.toArray;
+          result.toArray = function () {
+            return originalToArray.call(this)
+              .then((docs: any[]) => {
+                span.setStatus(SpanStatus.OK);
+                span.setAttribute('db.rows_affected', docs.length);
+                span.end();
+                return docs;
+              })
+              .catch((err: any) => {
+                span.setStatus(SpanStatus.ERROR, err.message);
+                span.setAttribute('error', true);
+                span.setAttribute('error.message', err.message);
+                span.end();
+                throw err;
+              });
+          };
+        }
+
+        return result;
+      };
+    }
+
+    if (config.debug) {
+      console.log('[DevSkin Agent] MongoDB instrumentation enabled');
+    }
+  } catch (error: any) {
+    if (agent.getConfig().debug) {
+      console.error('[DevSkin Agent] Failed to instrument MongoDB:', error.message);
+    }
+  }
+}

package/src/instrumentation/mysql.ts

@@ -0,0 +1,319 @@
+import { Agent } from '../agent';
+import { SpanBuilder } from '../span';
+import { SpanKind, SpanStatus } from '../types';
+
+/**
+ * Instrument MySQL and MySQL2 drivers for database monitoring
+ */
+export function instrumentMysql(agent: Agent): void {
+  try {
+    // Hook into Node's require system to intercept mysql/mysql2 loads
+    const Module = require('module');
+    const originalRequire = Module.prototype.require;
+
+    Module.prototype.require = function (id: string) {
+      const module = originalRequire.apply(this, arguments);
+
+      // Instrument mysql2 when it's loaded
+      if (id === 'mysql2' && module.Connection && !module.__devskin_instrumented) {
+        if (agent.getConfig().debug) {
+          console.log('[DevSkin Agent] Intercepted mysql2 load, instrumenting...');
+        }
+        instrumentMysql2(agent, module);
+        module.__devskin_instrumented = true;
+      }
+
+      // Instrument mysql when it's loaded
+      if (id === 'mysql' && module.Connection && !module.__devskin_instrumented) {
+        if (agent.getConfig().debug) {
+          console.log('[DevSkin Agent] Intercepted mysql load, instrumenting...');
+        }
+        instrumentMysqlLegacy(agent, module);
+        module.__devskin_instrumented = true;
+      }
+
+      return module;
+    };
+
+    // Also try to instrument if already loaded
+    try {
+      const mysql2 = require('mysql2');
+      if (mysql2 && mysql2.Connection && !mysql2.__devskin_instrumented) {
+        instrumentMysql2(agent, mysql2);
+        mysql2.__devskin_instrumented = true;
+      }
+    } catch {
+      // mysql2 not yet loaded
+    }
+
+    try {
+      const mysql = require('mysql');
+      if (mysql && mysql.Connection && !mysql.__devskin_instrumented) {
+        instrumentMysqlLegacy(agent, mysql);
+        mysql.__devskin_instrumented = true;
+      }
+    } catch {
+      // mysql not yet loaded
+    }
+  } catch (error: any) {
+    if (agent.getConfig().debug) {
+      console.error('[DevSkin Agent] Failed to instrument MySQL:', error.message);
+    }
+  }
+}
+
+/**
+ * Instrument mysql2 driver
+ */
+function instrumentMysql2(agent: Agent, mysql2: any): void {
+  const config = agent.getConfig();
+
+  // Patch Connection.prototype.query
+  const originalQuery = mysql2.Connection.prototype.query;
+  mysql2.Connection.prototype.query = function (sql: any, values: any, callback: any) {
+    if (!agent.shouldSample()) {
+      return originalQuery.call(this, sql, values, callback);
+    }
+
+    // Handle different call signatures
+    let actualSql = sql;
+    let actualValues = values;
+    let actualCallback = callback;
+
+    if (typeof sql === 'object') {
+      actualSql = sql.sql;
+      actualValues = sql.values;
+    }
+
+    if (typeof values === 'function') {
+      actualCallback = values;
+      actualValues = undefined;
+    }
+
+    // Extract connection info
+    const connectionConfig = this.config;
+    const dbName = connectionConfig?.database || 'unknown';
+    const host = connectionConfig?.host || 'localhost';
+    const port = connectionConfig?.port || 3306;
+    const user = connectionConfig?.user;
+
+    // Create span for the query
+    const span = new SpanBuilder(
+      `mysql.query`,
+      SpanKind.CLIENT,
+      config.serviceName!,
+      config.serviceVersion,
+      config.environment,
+      agent
+    );
+
+    // Extract query type (SELECT, INSERT, UPDATE, etc.)
+    const queryType = extractQueryType(actualSql);
+
+    // Set database attributes following OpenTelemetry semantic conventions
+    span.setAttributes({
+      'db.system': 'mysql',
+      'db.name': dbName,
+      'db.statement': normalizeQuery(actualSql),
+      'db.operation': queryType,
+      'db.user': user,
+      'net.peer.name': host,
+      'net.peer.port': port,
+      'db.connection_string': `mysql://${host}:${port}/${dbName}`,
+    });
+
+    span.setAttribute('span.kind', 'client');
+
+    const startTime = Date.now();
+
+    // Wrap callback to capture result/error
+    const wrappedCallback = (err: any, results: any, fields: any) => {
+      const duration = Date.now() - startTime;
+
+      if (err) {
+        span.setStatus(SpanStatus.ERROR, err.message);
+        span.setAttribute('error', true);
+        span.setAttribute('error.message', err.message);
+        span.setAttribute('error.type', err.code || 'Error');
+      } else {
+        span.setStatus(SpanStatus.OK);
+        // Add result metadata
+        if (results) {
+          if (Array.isArray(results)) {
+            span.setAttribute('db.rows_affected', results.length);
+          } else if (results.affectedRows !== undefined) {
+            span.setAttribute('db.rows_affected', results.affectedRows);
+          }
+        }
+      }
+
+      span.end();
+
+      if (actualCallback) {
+        actualCallback(err, results, fields);
+      }
+    };
+
+    // Call original query with wrapped callback
+    if (actualCallback) {
+      return originalQuery.call(this, actualSql, actualValues, wrappedCallback);
+    } else {
+      // Promise-based query
+      const query = originalQuery.call(this, actualSql, actualValues);
+
+      // Wrap promise
+      return query
+        .then((results: any) => {
+          const duration = Date.now() - startTime;
+          span.setStatus(SpanStatus.OK);
+          if (results && results[0]) {
+            if (Array.isArray(results[0])) {
+              span.setAttribute('db.rows_affected', results[0].length);
+            } else if (results[0].affectedRows !== undefined) {
+              span.setAttribute('db.rows_affected', results[0].affectedRows);
+            }
+          }
+          span.end();
+          return results;
+        })
+        .catch((err: any) => {
+          const duration = Date.now() - startTime;
+          span.setStatus(SpanStatus.ERROR, err.message);
+          span.setAttribute('error', true);
+          span.setAttribute('error.message', err.message);
+          span.setAttribute('error.type', err.code || 'Error');
+          span.end();
+          throw err;
+        });
+    }
+  };
+
+  if (config.debug) {
+    console.log('[DevSkin Agent] MySQL2 instrumentation enabled');
+  }
+}
+
+/**
+ * Instrument legacy mysql driver
+ */
+function instrumentMysqlLegacy(agent: Agent, mysql: any): void {
+  const config = agent.getConfig();
+
+  // Similar implementation for mysql driver
+  const originalQuery = mysql.Connection.prototype.query;
+  mysql.Connection.prototype.query = function (sql: any, values: any, callback: any) {
+    if (!agent.shouldSample()) {
+      return originalQuery.call(this, sql, values, callback);
+    }
+
+    let actualSql = sql;
+    let actualValues = values;
+    let actualCallback = callback;
+
+    if (typeof sql === 'object') {
+      actualSql = sql.sql;
+      actualValues = sql.values;
+    }
+
+    if (typeof values === 'function') {
+      actualCallback = values;
+      actualValues = undefined;
+    }
+
+    const connectionConfig = this.config;
+    const dbName = connectionConfig?.database || 'unknown';
+    const host = connectionConfig?.host || 'localhost';
+    const port = connectionConfig?.port || 3306;
+    const user = connectionConfig?.user;
+
+    const span = new SpanBuilder(
+      `mysql.query`,
+      SpanKind.CLIENT,
+      config.serviceName!,
+      config.serviceVersion,
+      config.environment,
+      agent
+    );
+
+    const queryType = extractQueryType(actualSql);
+
+    span.setAttributes({
+      'db.system': 'mysql',
+      'db.name': dbName,
+      'db.statement': normalizeQuery(actualSql),
+      'db.operation': queryType,
+      'db.user': user,
+      'net.peer.name': host,
+      'net.peer.port': port,
+      'db.connection_string': `mysql://${host}:${port}/${dbName}`,
+    });
+
+    span.setAttribute('span.kind', 'client');
+
+    const startTime = Date.now();
+
+    const wrappedCallback = (err: any, results: any, fields: any) => {
+      if (err) {
+        span.setStatus(SpanStatus.ERROR, err.message);
+        span.setAttribute('error', true);
+        span.setAttribute('error.message', err.message);
+      } else {
+        span.setStatus(SpanStatus.OK);
+        if (results) {
+          if (Array.isArray(results)) {
+            span.setAttribute('db.rows_affected', results.length);
+          } else if (results.affectedRows !== undefined) {
+            span.setAttribute('db.rows_affected', results.affectedRows);
+          }
+        }
+      }
+      span.end();
+
+      if (actualCallback) {
+        actualCallback(err, results, fields);
+      }
+    };
+
+    return originalQuery.call(this, actualSql, actualValues, wrappedCallback);
+  };
+
+  if (config.debug) {
+    console.log('[DevSkin Agent] MySQL (legacy) instrumentation enabled');
+  }
+}
+
+/**
+ * Extract query type from SQL statement
+ */
+function extractQueryType(sql: string): string {
+  if (typeof sql !== 'string') return 'unknown';
+
+  const normalized = sql.trim().toUpperCase();
+
+  if (normalized.startsWith('SELECT')) return 'SELECT';
+  if (normalized.startsWith('INSERT')) return 'INSERT';
+  if (normalized.startsWith('UPDATE')) return 'UPDATE';
+  if (normalized.startsWith('DELETE')) return 'DELETE';
+  if (normalized.startsWith('CREATE')) return 'CREATE';
+  if (normalized.startsWith('DROP')) return 'DROP';
+  if (normalized.startsWith('ALTER')) return 'ALTER';
+  if (normalized.startsWith('TRUNCATE')) return 'TRUNCATE';
+
+  return 'unknown';
+}
+
+/**
+ * Normalize query for better grouping
+ * Remove sensitive data while keeping structure
+ */
+function normalizeQuery(sql: string): string {
+  if (typeof sql !== 'string') return String(sql);
+
+  // Limit length to avoid huge spans
+  let normalized = sql.substring(0, 10000);
+
+  // Remove extra whitespace
+  normalized = normalized.replace(/\s+/g, ' ').trim();
+
+  return normalized;
+}