appdynamics/lib/probes/winston-probe.js

Performance Profiler and Monitor

exports.WinstonProbe = WinstonProbe;

function WinstonProbe(agent) {
  this.agent = agent;
  this.packages = ['winston'];
}

WinstonProbe.prototype.init = function () {};

WinstonProbe.prototype.attach = function (obj) {

  if(process.env.APPDYNAMICS_WINSTON_PROBE_DISABLE == true || process.env.APPDYNAMICS_WINSTON_PROBE_DISABLE == 'true') {
    return;
  }

  if(obj.__appdynamicsProbeAttached__) return;
  obj.__appdynamicsProbeAttached__ = true;
  let self = this;
  self.agent.on('destroy', function() {
    if(obj.__appdynamicsProbeAttached__) {
      delete obj.__appdynamicsProbeAttached__;
      self.agent.proxy.release(obj.Logger.prototype.write);
    }
  });

  self.agent.proxy.before(
    obj.Logger.prototype,
    "write",
    (obj, args) => this.handleLogWrite(obj, args)
  );
};

WinstonProbe.prototype.handleLogWrite = function (obj, args) {
  let self = this;

  const threadId =  self.agent.profiler.time().threadId;
  const txn = self.agent.profiler.getTransaction(threadId);

  let txnBtId = txn && txn.btGuid && self.agent.libagentConnector.getBusinessTransactionId(txn.btGuid) > 0
                ? self.agent.libagentConnector.getBusinessTransactionId(txn.btGuid) : '';

  if(self.agent.libagentConnector.getNodeProperty("opentelemetry-logs-push-enabled")
     && !self.agent.OtelLogger) {
    self.emitToOtel(args, txn, txnBtId);
  }

  if(!txn) {
    return;
  }

  if(process.env.appdynamics_log_metadata_enrichment  || self.agent.libagentConnector.getNodeProperty("enable-log-metadata-enrichment")) {
    return self.decorateMessage(args, txn, txnBtId);
  }
};

WinstonProbe.prototype.decorateMessage = function (args, txn, btId) {
  let self = this;

  for(let i = 0; i < args.length; i++) {
    let logMessage = args[i];

    let txnGuid = txn && txn.guid ? txn.guid : '';
    if(self.hasMetadataDefined(logMessage)) {
      self.updateMetadata(logMessage, txnGuid, btId);
    } else {
      var decorator = self.createDecorator(txnGuid, btId);
      if(decorator) {
        logMessage.message = decorator + ' ' + logMessage.message;
      }
    }
  }
  return args;
};

WinstonProbe.prototype.hasMetadataDefined = function (logMessage) {
  return logMessage.hasOwnProperty('appd_app_name')|| logMessage.hasOwnProperty('appd_tier_name')|| logMessage.hasOwnProperty('appd_node_name')
         || logMessage.hasOwnProperty('appd_request_guid') || logMessage.hasOwnProperty('appd_bt_id');
};

WinstonProbe.prototype.updateMetadata = function (logMessage, txnGuid, btId) {
  let self = this;
  let nodeId = self.agent.libagentConnector.getNodeId();
  if(logMessage.hasOwnProperty('appd_app_name')) {
    logMessage.appd_app_name = self.agent.opts.applicationName;
  }
  if(logMessage.hasOwnProperty('appd_tier_name')) {
    logMessage.appd_tier_name = self.agent.opts.tierName;
  }
  if(logMessage.hasOwnProperty('appd_node_id')) {
    logMessage.appd_node_id = nodeId;
  }
  if(logMessage.hasOwnProperty('appd_request_guid')) {
    logMessage.appd_request_guid = txnGuid;
  }
  if(logMessage.hasOwnProperty('appd_bt_id')) {
    logMessage.appd_bt_id = btId;
  }
};

WinstonProbe.prototype.createDecorator = function (txnGuid, btId) {
  let self = this;
  let decorator = '';
  let decoratorFields = process.env.appdynamics_log_metadata_fields;
  let opts = self.agent.opts;
  let nodeId = self.agent.libagentConnector.getNodeId();
  if(decoratorFields.includes('appd_app_name')) {
    decorator = self.addDecoratorField('appd_app_name', opts.applicationName, decorator);
  }
  if(decoratorFields.includes('appd_tier_name')) {
    decorator = self.addDecoratorField('appd_tier_name', opts.tierName, decorator);
  }
  if(decoratorFields.includes('appd_node_id')) {
    decorator = self.addDecoratorField('appd_node_id', nodeId, decorator);
  }
  if(decoratorFields.includes('appd_request_guid')) {
    decorator = self.addDecoratorField('appd_request_guid', txnGuid, decorator);
  }
  if(decoratorFields.includes('appd_bt_id')) {
    decorator = self.addDecoratorField('appd_bt_id', btId, decorator);
  }
  // strip leading space
  return decorator.slice(1);
};

WinstonProbe.prototype.addDecoratorField = function (name, value, decorator) {
  decorator += ' ' + name + '=' + value;
  return decorator;
};

WinstonProbe.prototype.emitToOtel = function (args, txn, btId) {
  var self = this;

  for(let i = 0; i < args.length; i++) {
    let logMessage = args[i];

    this.agent.OtelLogger.emit(txn,
                              btId,
                              logMessage,
                              self.agent.libagentConnector.filterLogMessage(logMessage.message),
                              self.agent.libagentConnector.getNodeProperty("opentelemetry-allowed-log-level"));
  }
};