MonitorableObject.hpp

Go to the documentation of this file.

 
#ifndef OPMONLIB_INCLUDE_OPMONLIB_MONITORABLEOBJECT_HPP_
#define OPMONLIB_INCLUDE_OPMONLIB_MONITORABLEOBJECT_HPP_
 
#include "opmonlib/Utils.hpp"
#include "opmonlib/OpMonFacility.hpp"
#include <opmonlib/opmon/monitoring_tree.pb.h>
 
#include "confmodel/OpMonConf.hpp"
#include "logging/Logging.hpp" // NOTE: if ISSUES ARE DECLARED BEFORE include logging/Logging.hpp, TLOG_DEBUG<<issue wont work.
 
#include <google/protobuf/message.h>
 
#include <limits>
#include <type_traits>
#include <map>
#include <memory>
#include <string>
#include <mutex>
 
namespace dunedaq {
 
  ERS_DECLARE_ISSUE( opmonlib,
             NonUniqueNodeName,
             name << " already present in the node list of " << opmon_id,
             ((std::string)name)((std::string)opmon_id) 
             )
      
  ERS_DECLARE_ISSUE( opmonlib,
             EntryWithNoData,
             "OpMonEntry of type " << type << " has no data",
             ((std::string)type)
           )
 
  ERS_DECLARE_ISSUE( opmonlib,
                     ErrorWhileCollecting,
                     "OpMon data collection failed in " << opmon_id,
                     ((std::string)opmon_id) )
 
}
 
 
namespace dunedaq::opmonlib {
 
  using OpMonLevel = std::invoke_result<decltype(&dunedaq::confmodel::OpMonConf::get_level),
                    dunedaq::confmodel::OpMonConf>::type;
  
  enum class SystemOpMonLevel : OpMonLevel {
    kDisabled = std::numeric_limits<OpMonLevel>::min(),
    kAll      = std::numeric_limits<OpMonLevel>::max()
  };
 
  enum class EntryOpMonLevel : OpMonLevel {
    kTopPriority     = std::numeric_limits<OpMonLevel>::min(),
    kEventDriven     = std::numeric_limits<OpMonLevel>::max()/4,
    kDefault         = std::numeric_limits<OpMonLevel>::max()/2,
    kLowestPrioriry  = std::numeric_limits<OpMonLevel>::max()-1
  };
 
  template <class T>
  constexpr auto to_level( T v ) {
    return static_cast<typename std::underlying_type<T>::type>(v);
  }
  
  
class MonitorableObject
{
public:
 
  using NodePtr = std::weak_ptr<MonitorableObject>;
  using NewNodePtr = std::shared_ptr<MonitorableObject>;
  using ElementId = std::string;
 
  friend class OpMonManager;
  
  MonitorableObject( const MonitorableObject & ) = delete ;
  MonitorableObject & operator = ( const MonitorableObject &) = delete;
  MonitorableObject( MonitorableObject && ) = delete;
  MonitorableObject & operator = (MonitorableObject &&) = delete;    
  
  virtual ~MonitorableObject() = default;
  
  auto get_opmon_id() const noexcept { return m_parent_id + m_opmon_name; }
 
  auto get_opmon_level() const noexcept { return m_opmon_level.load(); }
  
  static bool publishable_metric( OpMonLevel entry, OpMonLevel system ) noexcept {
    return (entry < system);
  }
  
protected:

  MonitorableObject() = default;

  void register_node( ElementId name, NewNodePtr ) ;

  void publish( google::protobuf::Message &&,
        CustomOrigin && co = {},
        OpMonLevel l = to_level(EntryOpMonLevel::kDefault) ) const noexcept ;

  virtual void generate_opmon_data() {return;}
 
  
private:
     
  opmon::MonitoringTreeInfo collect() noexcept ;
  
  void set_opmon_level( OpMonLevel ) noexcept; 

  void inherit_parent_properties( const MonitorableObject & parent );   // funcion called on the children as well
 
  MonitorableObject( ElementId name, ElementId parent_id = "" )
    : m_parent_id()
    , m_opmon_name(name) {
    m_parent_id.set_session(parent_id);
  }
  
  std::map<ElementId, NodePtr> m_nodes ;
  std::mutex m_node_mutex;
 
  using facility_ptr_t = std::shared_ptr<opmonlib::OpMonFacility>;
  std::atomic<facility_ptr_t> m_facility{s_default_facility};
  dunedaq::opmon::OpMonId m_parent_id;
  std::atomic<OpMonLevel> m_opmon_level = to_level(SystemOpMonLevel::kAll);
  ElementId m_opmon_name;
 
  static facility_ptr_t s_default_facility;
  
  // info for monitoring the monitoring structure
  using const_metric_counter_t = std::invoke_result<decltype(&dunedaq::opmonlib::opmon::MonitoringTreeInfo::n_published_measurements),
                            dunedaq::opmonlib::opmon::MonitoringTreeInfo>::type;
  using metric_counter_t = std::remove_const<const_metric_counter_t>::type;
  mutable std::atomic<metric_counter_t> m_published_counter{0};
  mutable std::atomic<metric_counter_t> m_ignored_counter{0};
  mutable std::atomic<metric_counter_t> m_error_counter{0};
 
  using const_time_counter_t = std::invoke_result<decltype(&dunedaq::opmonlib::opmon::MonitoringTreeInfo::cpu_elapsed_time_us),
                          dunedaq::opmonlib::opmon::MonitoringTreeInfo>::type;
  using time_counter_t = std::remove_const<const_metric_counter_t>::type;
  mutable std::atomic<time_counter_t> m_cpu_us_counter{0};
};
 
 
  class OpMonLink : public MonitorableObject {
  public:
    using MonitorableObject::register_node;
  };
  
} // namespace dunedaq::opmonlib
 
#endif // OPMONLIB_INCLUDE_OPMONLIB_MONITORABLEOBJECT_HPP_