ca-apm-probe/lib/probes/pg.js

CA APM Node.js Agent monitors real-time health and performance of Node.js applications

 
/**
 * Copyright (c) 2015 CA. All rights reserved.
 *
 * This software and all information contained therein is confidential and proprietary and
 * shall not be duplicated, used, disclosed or disseminated in any way except as authorized
 * by the applicable license agreement, without the express written permission of CA. All
 * authorized reproductions must be marked with this language.
 *
 * EXCEPT AS SET FORTH IN THE APPLICABLE LICENSE AGREEMENT, TO THE EXTENT
 * PERMITTED BY APPLICABLE LAW, CA PROVIDES THIS SOFTWARE WITHOUT WARRANTY
 * OF ANY KIND, INCLUDING WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL CA BE
 * LIABLE TO THE END USER OR ANY THIRD PARTY FOR ANY LOSS OR DAMAGE, DIRECT OR
 * INDIRECT, FROM THE USE OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, LOST
 * PROFITS, BUSINESS INTERRUPTION, GOODWILL, OR LOST DATA, EVEN IF CA IS
 * EXPRESSLY ADVISED OF SUCH LOSS OR DAMAGE.
 */

var path = require('path');
var agent = require('../agent');
var proxy = require('../proxy');
var util = require('util');
var logger = require("../logger.js");
var targetModule = new Object;

module.exports = function(pg) {
  targetModule.pg = pg;
  targetModule.Query = findQuery(targetModule.pg, require);
  targetModule.Client = findClient(targetModule.pg, require);
  // targetModule.Connection = findConnection(targetModule.pg, require);
  targetModule.methodMap = getMethodsWithProbes();
  var methodMap = targetModule.methodMap;
//};
//
//function instrument(methodMap) {

  var Connection = targetModule.Connection;
  var Query = targetModule.Query;
  var Client = targetModule.Client;
  // var Pool = targetModule.Connection;
 
  proxy.before(Client.prototype, 'query', function(obj, args, storage) {
    if (agent.paused) return;
    // check if we need to instrument
    if (methodMap[0] == "skip_instrument")    { return; }

    var command = args.length > 0 ? args[0] : undefined;
    console.log(command);

    var eventNameFormatted = 'pg.query';
    //console.log(util.inspect(obj, { showHidden: true, depth: 1 }));
    var dburl = 'Postgres on localhost-3306 (Postgresql DB)';
    if (obj.database) {
      dburl = 'postgresql://' + obj.host + ':' + obj.port + '/' + obj.database;
    }
    var ctx = storage.get('ctx');
    var debug = logger.isDebug();
    if (debug) {    
	    if (ctx != null) {
	      logger.debug('pg[%d %d %d]: %s', ctx.txid, ctx.lane, ctx.evtid, command);
	    }
	    else {
	      logger.debug('pg.query - no context: %s', command);
	      logger.debug((new Error('No context')).stack);
	    }
    }
    ctx = agent.asynchEventStart(ctx, eventNameFormatted, { url: dburl, query: command});
    storage.set('ctx', ctx);

    proxy.callback(args, -1, function(obj, args, storage) {
      var errorObject = agent.checkAndSetErrorObject(args, 'pgError');
      if (ctx != null) {
    	  if (debug) {
    		  logger.debug('pg[%d %d %d]: callback', ctx.txid, ctx.lane, ctx.evtid);
    	  }
    	  ctx = agent.asynchEventDone(ctx, eventNameFormatted, null, errorObject);
    	  storage.set('ctx', ctx);
      }
      else {
    	if (debug) {
    		logger.debug('pg - no context: callback');
    		logger.debug((new Error('No context')).stack);
        }
      }
    }, function(obj, args) {
      if (ctx) {
    	if (debug) {
    		logger.debug('pg[%d %d %d]: finish', ctx.txid, ctx.lane, ctx.evtid);
    	}
    	agent.asynchEventFinish(ctx);
      }
      else {
    	if (debug) {
    		logger.debug('pg - no context: finish');
    		logger.debug((new Error('No context')).stack);
    	}
      }
    });
  });


}



// given module pg, search the require cache for the corresponding
// Connection prototype
function findConnection(pg, require) {
  var cache = require.cache;
  for (var key in cache) {
    var candidate = cache[key];
    if (candidate.exports !== pg) {
      continue;
    }

    var dirname = path.dirname(candidate.filename);
    var filename = path.join(dirname, 'connection.js');
    try {
      return require(filename);
    } catch (e) {
      return null;
    }
  }
  return null;
}

function findQuery(pg, require) {
  var cache = require.cache;
  for (var key in cache) {
    var candidate = cache[key];
    if (candidate.exports !== pg) {
      continue;
    }

    var dirname = path.dirname(candidate.filename);
    var filename = path.join(dirname, 'query.js');
    try {
      return require(filename);
    } catch (e) {
      return null;
    }
  }
  return null;
}

function findClient(pg, require) {
  var cache = require.cache;
  for (var key in cache) {
    var candidate = cache[key];
    if (candidate.exports !== pg) {
      continue;
    }

    var dirname = path.dirname(candidate.filename);
    var filename = path.join(dirname, 'client.js');
    try {
      return require(filename);
    } catch (e) {
      return null;
    }
  }
  return null;
}


function getMethodsWithProbes() {
	if ( !targetModule.methodMap)
	{
		var mt =new Object;
        mt[0]='pg#query';
	    targetModule.methodMap =  mt;
	}
    return targetModule.methodMap;
}

function instrument(methodMap)
{
	targetModule.methodMap = methodMap;
}

module.exports.getMethodsWithProbes = getMethodsWithProbes;

module.exports.instrument = instrument.bind(module);