openhim-core/lib/metrics.js

The OpenHIM core application that provides logging and routing of http requests

var Channel, Q, Transaction, authorisation, fetchChannelMetrics, fetchGlobalLoadTimeMetrics, fetchGlobalStatusMetrics, getAllowedChannelIDs, getAllowedChannels, logger, moment, mongoose;

Transaction = require('./model/transactions').Transaction;

Channel = require('./model/channels').Channel;

moment = require('moment');

logger = require('winston');

mongoose = require('mongoose');

authorisation = require('./api/authorisation');

Q = require('q');

exports.fetchGlobalLoadTimeMetrics = fetchGlobalLoadTimeMetrics = function(requestingUser, filtersObject) {
  var from, to;
  if (filtersObject.startDate && filtersObject.endDate) {
    filtersObject.startDate = filtersObject.startDate.toString().replace(/"/g, '');
    filtersObject.endDate = filtersObject.endDate.toString().replace(/"/g, '');
    from = new Date(filtersObject.startDate);
    to = new Date(filtersObject.endDate);
    delete filtersObject.startDate;
    delete filtersObject.endDate;
  } else {
    from = moment().subtract(1, "weeks").toDate();
    to = moment().toDate();
  }
  filtersObject["request.timestamp"] = {
    $lt: to,
    $gt: from
  };
  return getAllowedChannelIDs(requestingUser).then(function(allowedChannelIDs) {
    filtersObject["channelID"] = {
      $in: allowedChannelIDs
    };
    return Transaction.aggregate([
      {
        $match: filtersObject
      }, {
        $group: {
          _id: {
            year: {
              $year: "$request.timestamp"
            },
            month: {
              $month: "$request.timestamp"
            },
            day: {
              $dayOfMonth: "$request.timestamp"
            },
            hour: {
              $hour: "$request.timestamp"
            }
          },
          load: {
            $sum: 1
          },
          avgResp: {
            $avg: {
              $subtract: ["$response.timestamp", "$request.timestamp"]
            }
          }
        }
      }
    ]).exec();
  });
};

exports.fetchGlobalStatusMetrics = fetchGlobalStatusMetrics = function(requestingUser, filtersObject) {
  var from, to;
  if (filtersObject.startDate && filtersObject.endDate) {
    filtersObject.startDate = filtersObject.startDate.toString().replace(/"/g, '');
    filtersObject.endDate = filtersObject.endDate.toString().replace(/"/g, '');
    from = new Date(filtersObject.startDate);
    to = new Date(filtersObject.endDate);
    delete filtersObject.startDate;
    delete filtersObject.endDate;
  } else {
    from = moment().subtract(1, "weeks").toDate();
    to = moment().toDate();
  }
  filtersObject["request.timestamp"] = {
    $lt: to,
    $gt: from
  };
  return getAllowedChannelIDs(requestingUser).then(function(allowedChannelIDs) {
    filtersObject["channelID"] = {
      $in: allowedChannelIDs
    };
    return Transaction.aggregate([
      {
        $match: filtersObject
      }, {
        $group: {
          _id: {
            channelID: "$channelID"
          },
          failed: {
            $sum: {
              $cond: [
                {
                  $eq: ["$status", "Failed"]
                }, 1, 0
              ]
            }
          },
          successful: {
            $sum: {
              $cond: [
                {
                  $eq: ["$status", "Successful"]
                }, 1, 0
              ]
            }
          },
          processing: {
            $sum: {
              $cond: [
                {
                  $eq: ["$status", "Processing"]
                }, 1, 0
              ]
            }
          },
          completed: {
            $sum: {
              $cond: [
                {
                  $eq: ["$status", "Completed"]
                }, 1, 0
              ]
            }
          },
          completedWErrors: {
            $sum: {
              $cond: [
                {
                  $eq: ["$status", "Completed with error(s)"]
                }, 1, 0
              ]
            }
          }
        }
      }
    ]).exec();
  });
};

exports.fetchChannelMetrics = fetchChannelMetrics = function(time, channelId, userRequesting, filtersObject) {
  var channelID, from, groupObject, to;
  channelID = mongoose.Types.ObjectId(channelId);
  if (filtersObject.startDate && filtersObject.endDate) {
    filtersObject.startDate = filtersObject.startDate.toString().replace(/"/g, '');
    filtersObject.endDate = filtersObject.endDate.toString().replace(/"/g, '');
    from = new Date(filtersObject.startDate);
    to = new Date(filtersObject.endDate);
  } else {
    from = moment().startOf('day').toDate();
    to = moment().endOf('day').toDate();
  }
  filtersObject.channelID = channelID;
  filtersObject["request.timestamp"] = {
    $lt: to,
    $gt: from
  };
  delete filtersObject.startDate;
  delete filtersObject.endDate;
  groupObject = {};
  groupObject._id = {};
  groupObject = {
    _id: {
      year: {
        $year: "$request.timestamp"
      },
      month: {
        $month: "$request.timestamp"
      }
    },
    load: {
      $sum: 1
    },
    avgResp: {
      $avg: {
        $subtract: ["$response.timestamp", "$request.timestamp"]
      }
    }
  };
  switch (time) {
    case "minute":
      groupObject._id.day = {
        $dayOfMonth: "$request.timestamp"
      };
      groupObject._id.hour = {
        $hour: "$request.timestamp"
      };
      groupObject._id.minute = {
        $minute: "$request.timestamp"
      };
      break;
    case "hour":
      groupObject._id.day = {
        $dayOfMonth: "$request.timestamp"
      };
      groupObject._id.hour = {
        $hour: "$request.timestamp"
      };
      break;
    case "day":
      groupObject._id.day = {
        $dayOfMonth: "$request.timestamp"
      };
      break;
    case "week":
      groupObject._id.week = {
        $week: "$request.timestamp"
      };
      break;
    case "month":
    case "year":
      delete groupObject._id.month;
      break;
    case "status":
      groupObject = {
        _id: {
          channelID: "$channelID"
        },
        failed: {
          $sum: {
            $cond: [
              {
                $eq: ["$status", "Failed"]
              }, 1, 0
            ]
          }
        },
        successful: {
          $sum: {
            $cond: [
              {
                $eq: ["$status", "Successful"]
              }, 1, 0
            ]
          }
        },
        processing: {
          $sum: {
            $cond: [
              {
                $eq: ["$status", "Processing"]
              }, 1, 0
            ]
          }
        },
        completed: {
          $sum: {
            $cond: [
              {
                $eq: ["$status", "Completed"]
              }, 1, 0
            ]
          }
        },
        completedWErrors: {
          $sum: {
            $cond: [
              {
                $eq: ["$status", "Completed with error(s)"]
              }, 1, 0
            ]
          }
        }
      };
      break;
  }
  return Transaction.aggregate([
    {
      $match: filtersObject
    }, {
      $group: groupObject
    }
  ]).exec();
};

getAllowedChannels = function(requestingUser) {
  return authorisation.getUserViewableChannels(requestingUser).then(function(allowedChannelsArray) {
    var allowedChannelIDs, channel, fn, i, len, promises;
    allowedChannelIDs = [];
    promises = [];
    fn = function(channel) {
      var deferred;
      deferred = Q.defer();
      allowedChannelIDs.push({
        _id: channel._id,
        name: channel.name
      });
      deferred.resolve();
      return promises.push(deferred.promise);
    };
    for (i = 0, len = allowedChannelsArray.length; i < len; i++) {
      channel = allowedChannelsArray[i];
      fn(channel);
    }
    return (Q.all(promises)).then(function() {
      return allowedChannelIDs;
    });
  });
};

getAllowedChannelIDs = function(requestingUser) {
  return authorisation.getUserViewableChannels(requestingUser).then(function(allowedChannelsArray) {
    var allowedChannelIDs, channel, fn, i, len, promises;
    allowedChannelIDs = [];
    promises = [];
    fn = function(channel) {
      var deferred;
      deferred = Q.defer();
      allowedChannelIDs.push(channel._id);
      deferred.resolve();
      return promises.push(deferred.promise);
    };
    for (i = 0, len = allowedChannelsArray.length; i < len; i++) {
      channel = allowedChannelsArray[i];
      fn(channel);
    }
    return (Q.all(promises)).then(function() {
      return allowedChannelIDs;
    });
  });
};

exports.getAllowedChannels = getAllowedChannels;

exports.getAllowedChannelIDs = getAllowedChannelIDs;

//# sourceMappingURL=metrics.js.map