NdmcMetric.h

Go to the documentation of this file.

/**
 * NdmcMetric header file
 * $Id: NdmcMetric.h,v 1.25.10.1 2019/09/27 00:07:18 slin Exp $
 */
#ifndef __NDMC_METRIC_H_
#define __NDMC_METRIC_H_

#include <typeinfo>
#include <sstream>
#include <sys/times.h>
#include <boost/algorithm/string.hpp> // to_lower
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "NovaDAQMonitorClient/Ndmc.h"
#include "NovaDAQMonitorClient/NdmcMetricABC.h"
#include "NovaDAQMonitorClient/NdmcClientService.h"

//extern "C" {
#include "ganglia.h"
//}

class NdmcMetricTest;
class NdmcClientTest;

NDMC_NAMESPACE_BEGIN

/**
 * NdmcMetric
 *
 * This class implements a single custom metric to be sent by a client
 * to the DAQ Monitor Server.
 * 
 * @author Susan Kasahara 
 * @author <a href="mailto:schubert@physics.umn.edu">schubert@physics.umn.edu</a>
 * @date May 05 2010 (creation)
 */
template <class T>
class NdmcMetric : public NdmcMetricABC {

  friend class ::NdmcMetricTest;
  friend class ::NdmcClientTest;

 public:

  // Constructors/Destructors
  NdmcMetric(std::string name, std::string unit="", MetricType_t metricType = VALUE,
         int32_t maxdeltatime=30, int32_t lifetime=60, ganglia_slope_t slope=GANGLIA_SLOPE_BOTH,
         int32_t partition = -1, std::string appName="", std::string groupName="",
         std::string title = "", std::string desc = "");
  virtual ~NdmcMetric();

  // State changing methods
  bool setValue(T value, double weight=1., int npar = 0, double* par = 0);
  bool send();

  // Accessor methods
  std::string getName() const { return _name; }
  std::string getUnit() const { return _unit; }
  int32_t getPartition() const { return _partition; }
  std::string getApplicationName() const { return _applicationName; }
  std::string getGroupName() const { return _groupName; }
  std::string getTitle() const { return _title; }
  std::string getDescription() const { return _description; }
  MetricType_t getMetricType() const { return _metricType; }
  int32_t getMaxDeltaTime() const { return _maxDeltaTime; }
  int32_t getLifeTime() const { return _lifeTime; }
  ganglia_slope_t getSlope() const { return _slope; }
  std::string getType() const { return _type; }
  T getValue() const { return _value; }
  bool getLastValueSent(T& lastValueSent) const;
  double getSumWX() const { return _sumwx; }
  double getSumW() const { return _sumw; }
  double getNW() const { return _nw; }
  double getSumWXSq() const { return _sumwxsq; }
  bool isValueSet() const { return _isValueSet; }
  std::string getMetricName() const { return _metricName; }

  // State changing methods
  void resetValue() { if ( _metricType == HEARTBEAT ) return;
                      _value = 0; _sumw = 0; _nw = 0; _sumwx = 0; _sumwxsq = 0;
                      _isValueSet = false; }
  void setApplicationName(std::string appName);
  void setGroupName(std::string groupName);
  void setPartition(int32_t partition);
  void setTitle(std::string title);
  void setDescription(std::string description);

 private:

  std::string _name; /**< Name of this metric */
  std::string _unit; /**< Unit of metric ("bytes","kB/s",...) */
  MetricType_t _metricType; /**< Metric type */
  int32_t _maxDeltaTime; /**< Maximum time in seconds between gmetric calls */
  int32_t _lifeTime; /**< Lifetime in seconds of this metric, default 0 => unlimited */
  ganglia_slope_t _slope; /**< Slope of metric (zero (fixed), positive (counter),negative, both) */
  std::string _type; /**< Type of metric as string ("uint32","int32",...) */
  T _value; /**< Value of metric */
  double _sumwx; /**< summed weight*value, used for AVERAGE & STDEV */
  double _sumw; /**< summed weight, used for MetricType::AVERAGE & STDEV */
  double _nw; /**< summed number of non-zero weight entries, used for STDEV */
  double _sumwxsq; /**< summed weight*value*value, used for STDEV */ 
  bool _isValueSet; /**< If value is currently set, then true */
  clock_t _lastSendTime; /**< Last metric send time */
  T _lastValueSent; /**< Last metric value sent */
  bool _valueHasBeenSent; /**< At least one value has been sent */
  int32_t _partition; /**< Partition */
  std::string _applicationName; /**< Application name */
  std::string _groupName; /**< Group name */
  std::string _title; /**< Title to be displayed over metric */
  std::string _description; /**< Description of metric displayed when mousing-over graph */
  std::string _metricName; /**< <name of metric>_A<appname>_P<partition> */
  Ganglia_metric_t _gMetric; /**< Ganglia metric structure */

  // private methods
  std::string _getType() const;
  double _timeSinceLastSend(clock_t& currentwalltime);
  bool _calculateSendValue(T& sendValue, double timeSinceLastSend=0);
  void _updateMetricName();

};

/**
 * Constructor
 */
template <class T>
NdmcMetric<T>::NdmcMetric(std::string name, std::string unit, MetricType_t metricType,
                          int32_t maxDeltaTime, int32_t lifeTime, ganglia_slope_t slope,
                          int32_t partition, std::string appName, std::string groupName,
                          std::string title, std::string description) : 
              _name(name), _unit(unit), _metricType(metricType), 
              _maxDeltaTime(maxDeltaTime),_lifeTime(lifeTime), _slope(slope), _value(0),
              _sumwx(0),_sumw(0),_nw(0),_sumwxsq(0),_isValueSet(false),_lastSendTime(0),
              _lastValueSent(0), _valueHasBeenSent(false), _partition(partition), 
              _applicationName(appName), _groupName(groupName), _title(title), 
              _description(description), _metricName("")  {

  LOG_DEBUG("NdmcMetric") << "NdmcMetric::ctor @" << this << "." << std::endl;

  _type = _getType();
  
  Ganglia_pool_t globalContext = NdmcClientService::instance().getGlobalContext();
  // Create the message container
  _gMetric = Ganglia_metric_create(globalContext);
  std::ostringstream oss;
  if ( !_gMetric ) {
    ::mf::LogError("NdmcMetric") 
        << "NdmcMetric::ctor - Unable to allocate gmetric structure for metric " 
        << name.c_str() << "." << std::endl;
    return;
  }
  else {
    oss << "NdmcMetric::ctor - Constructed metric " << name.c_str();
  }

  struct tms ctime;
  clock_t wall = times(&ctime);
  _lastSendTime = wall;

  if ( _metricType == HEARTBEAT ) setValue(1);
   
  setPartition(partition);
  setApplicationName(appName);
  setGroupName(groupName);

  if ( !title.empty() ) setTitle(title);
  if ( !description.empty() ) setDescription(description);

  oss << ", Partition " << getPartition()  << ", AppName \"" << getApplicationName() 
      << "\", GroupName \"" << getGroupName() << "\".";


  ::mf::LogInfo("NdmcMetric") << oss.str() << std::endl;

}

/**
 * Destructor
 */
template <class T>
NdmcMetric<T>::~NdmcMetric() {

  LOG_DEBUG("NdmcMetric") << "NdmcMetric::dtor @" << this << "." << std::endl;

  Ganglia_metric_destroy(_gMetric);

  ::mf::LogInfo("NdmcMetric") << "NdmcMetric::dtor - Destroyed metric " << getName()
      << ", Partition " << getPartition()  << ", AppName \"" << getApplicationName() 
      << "\", GroupName \"" << getGroupName() << "\"." << std::endl;

}

/**
 * Get last value sent for this metric.
 * @param lastValueSent reference to return value.
 * @return true if successful, else false if no metric yet sent.
 */
template <class T>
bool NdmcMetric<T>::getLastValueSent(T& lastValueSent) const {

  if ( !_valueHasBeenSent ) return false;

  lastValueSent = _lastValueSent;
  return true;

}

/**
 * Set new partition.
 * @param partition - partition number (0,1,2,3).  -1 => no partition.
 *              This is the partition number assigned to the application
 *              on startup.  If partition number is not -1 (default), 
 *              the partition number will be tacked on the metric
 *              name as <metricname>_A<appname>_P<partition>.
 */
template <class T>
void NdmcMetric<T>::setPartition(int32_t partition) {

  _partition = partition;
  _updateMetricName();

}

/**
 * Set new application name (optional). Application name will be set to
 * lower case.  
 * Application name is used to distinguish between different
 * applications running on the same node in the same partition.
 * For example, two event displays (Far & Near) may have application names
 * evdfar and evdnear to distinguish the results in the DAQ Monitor web
 * display and database.  It should not be used to distinguish between
 * application running for the same purpose on different nodes, or on different
 * partitions. 
 *
 * @param appName - application name (optional).  Defaults to "".  If specified
 *            the application name will be tacked onto the metric name
 *            as <metricname>_A<appname>_P<partition>. 
 */
template <class T>
void NdmcMetric<T>::setApplicationName(std::string appName) {

  _applicationName = appName;
  boost::algorithm::to_lower(_applicationName);
  _updateMetricName();

}

/**
 * Set new group name. 
 * The group name is used to specify which group the metric will be displayed
 * as part of in the DAQ Monitor web display.  
 * @param groupName - group name (optional).  Defaults to "". If specified
 *                    the metric will be will be displayed as part of groupName
 *                    in the web display, else it will be displayed as part of 
 *                    the "no group" group.  The group name is meta data and is
 *                    not stored directly in the database file.  A metric can
 *                    be reassigned to a new group at any time without losing the
 *                    continuity of the data stored in the database. 
 */
template <class T>
void NdmcMetric<T>::setGroupName(std::string groupName) {

  _groupName = groupName;
  // Use _set instead of _add so that new group name will override previous
  // GSD -- Temp switch to _add -- there is no Ganglia_metadata_set in 3_6_0
  Ganglia_metadata_add(_gMetric, (char*)"GROUP", (char*)_groupName.c_str());

}

/**
 * Set new title. 
 * The title is used to specify the title which will be displayed on the graph
 * of the metric in the web display.  
 * If not specified, the title will default to "<metricname> P<partition>" if
 * the partition has been set, else just "<metricname>".
 * @param title - metric graph title
 */
template <class T>
void NdmcMetric<T>::setTitle(std::string title) {

  _title = title;
  // Use _set instead of _add so that new title will override previous
  // GSD -- Temp switch to _add -- there is no Ganglia_metadata_set in 3_6_0
  Ganglia_metadata_add(_gMetric, (char*)"TITLE", (char*)_title.c_str());

}

/**
 * Set new description. 
 * The description is used to specify the description which will be displayed on 
 * the graph when mousing over the graph in the web display.
 * @param description - metric graph description
 */
template <class T>
void NdmcMetric<T>::setDescription(std::string desc) {

  _description = desc;
  // Use _set instead of _add so that new description will override previous
  // GSD -- Temp switch to _add -- there is no Ganglia_metadata_set in 3_6_0
  Ganglia_metadata_add(_gMetric, (char*)"DESC", (char*)_description.c_str());

}

/**
 * Update metric name if either partition number or application name is changed.
 * Metric name has the form:
 * <metric>_A<appname>_P<partition> if both appname and partition are defined, else
 * <metric>_A<appname> if no partition
 * <metric>_P<partition> if no appname
 * <metric> if no partition or appname
 * For example, "MicroSlice Rate_Adcmapp_P0".  
 */
template <class T>
void NdmcMetric<T>::_updateMetricName() {

  std::ostringstream oss;
  oss << getName();
  if ( !(getApplicationName().empty()) ) oss << "_A" << getApplicationName();
  if ( getPartition() >= 0 ) oss << "_P" << getPartition();
  _metricName = oss.str();

}

/**
 * setValue
 */
template <class T>
bool NdmcMetric<T>::setValue(T value, double weight, int npar, double* par) {

  switch ( _metricType ) {

  case VALUE:
  case HEARTBEAT:
    _value = value;
    break;

  case COUNTER:
  case RATE:
    _value += value;
     break;

  case STDEV:
    if ( npar == 0 ) {
      _sumwxsq += weight*value*value;
      _sumwx  += weight*value;
      _sumw += weight;
      if ( weight > 0.) _nw += 1;
    }
    else {
      // user has provided partial sums, assume weight is just count in partial sums
      _sumwxsq += par[0]; 
      _sumwx += value;
      _sumw += weight;
      _nw += weight;
    }
    break;

  case AVERAGE:
    _sumwx  += weight*value;
    _sumw += weight;
    break;

  case MINIMUM:
    if ( !_isValueSet || value < _value ) _value = value;
    break;

  case MAXIMUM:
    if ( !_isValueSet || value > _value ) _value = value; 
    break;

  default:
    ::mf::LogError("NdmcMetric") << "NdmcMetric::setValue - has unknown metric type " <<
      _metricType << " for metric " << getMetricName() << "." << std::endl;
    return false;
  }

  _isValueSet = true;

  return true;
  
}

/**
 * send gmetric value already set
 */
template <class T>
bool NdmcMetric<T>::send() {

  if (!_isValueSet ) return false; // no value set since last call to send
 
  clock_t lastSendTime = 0;
  double timeSinceLastSend = _timeSinceLastSend(lastSendTime);

  T sendValue;
  if ( !_calculateSendValue(sendValue,timeSinceLastSend) ) return false;

  std::stringstream ssval;
  ssval << sendValue;

  int rval = Ganglia_metric_set(_gMetric,(char*)getMetricName().c_str(),
               (char*)ssval.str().c_str(),(char*)getType().c_str(),
               (char*)getUnit().c_str(),getSlope(), getMaxDeltaTime(),getLifeTime());

  switch (rval) {
  case 1:
    ::mf::LogError("NdmcMetric") << "NdmcMetric::send - gmetric parameters invalid for metric: " 
                           << getMetricName() << "." << std::endl;
    return false;
  case 2:
    ::mf::LogError("NdmcMetric") 
        << "NdmcMetric::send - one of the gmetric parameters has an invalid character for metric: "
        << getMetricName() << "." << std::endl;
    return false;
  case 3:
    ::mf::LogError("NdmcMetric") << "NdmcMetric::send - "
                         << "gmetric type parameter is not a valid type for metric: " 
                         << getMetricName() << std::endl;
    return false;
  case 4:
    ::mf::LogError("NdmcMetric") 
        << "NdmcMetric::send - gmetric value parameter does not represent a number for metric: " 
        << getMetricName() << "." << std::endl;
    return false;
  default:
    break;
  }

  Ganglia_udp_send_channels_t sendChannels = NdmcClientService::instance().getSendChannels();

  LOG_DEBUG("NdmcMetric") << "NdmcMetric::send() - send value " << sendValue << " for metric "
                          << getMetricName() << "." << std::endl;
  rval = Ganglia_metric_send(_gMetric,sendChannels);
  if ( rval ) {
    ::mf::LogError("NdmcMetric") << "NdmcMetric::send - Error sending to " << rval 
                          << " channels " << "for metric: " << getMetricName() << "." 
                          << std::endl;
    return false;
  }
  
  _lastValueSent = sendValue;
  _valueHasBeenSent = true;
  _lastSendTime = lastSendTime;
  resetValue();
  return true;

}

/**
 * Calculate value to send based on metric type. 
 * @param sendValue reference to be filled by method
 * @param timeSinceLastSend is required if metrictype is RATE, otherwise ignored.
 * @return true or false if not successful. 
 */
template <class T>
bool NdmcMetric<T>::_calculateSendValue(T& sendValue, double timeSinceLastSend) {

  switch ( _metricType ) {

  case VALUE:
  case COUNTER:
  case MAXIMUM:
  case MINIMUM:
  case HEARTBEAT:
    sendValue = _value;
    break;

  case RATE:
     if ( timeSinceLastSend != 0 ) sendValue = T(double(_value)/timeSinceLastSend);
     else return false;
     break;

  case AVERAGE:
    if ( _sumw != 0 ) sendValue = T(_sumwx/_sumw);
    else return false;
    break;

  case STDEV: {
    double denom = _sumw*_sumw*(_nw-1);
    if ( denom != 0 ) sendValue = T( sqrt((_sumwxsq*_sumw - _sumwx*_sumwx)*_nw/denom) );
    else return false;
  }
    break;

  default:
    ::mf::LogError("NdmcMetric") << "NdmcMetric::_calculateSendValue - unknown metric type " <<
      _metricType << "." << std::endl;
    return false;
  }

  return true;

}



/**
 * Access the data type
 * Return "unknown" if unknown.
 */
template <class T>
std::string NdmcMetric<T>::_getType() const {

  if ( typeid(T) == typeid(int8_t) ) return "int8";
  else if ( typeid(T) == typeid(uint8_t) ) return "uint8";
  else if ( typeid(T) == typeid(int16_t) ) return "int16";
  else if ( typeid(T) == typeid(uint16_t) ) return "uint16";
  else if ( typeid(T) == typeid(int32_t) ) return "int32";
  else if ( typeid(T) == typeid(uint32_t) ) return "uint32";
  else if ( typeid(T) == typeid(float) ) return "float";
  else if ( typeid(T) == typeid(double) ) return "double";  
  
  ::mf::LogError("NdmcMetric") << "NdmcMetric::getType - Templated type not supported." << std::endl;
  return "Unknown";

}

/**
 * Time since last send (or since construction on first call) in seconds
 * @param reference in which current time will be stored on output
 * @return deltaw since _lastSendTime
 */
template <class T>
double NdmcMetric<T>::_timeSinceLastSend(clock_t& currenttime) {

  struct tms ctime;
  currenttime = times(&ctime);
  double deltaw = ((double)(currenttime - _lastSendTime))*10000./CLOCKS_PER_SEC;
  return deltaw;

}

NDMC_NAMESPACE_END

#endif