MonitorableObject.hpp

Go to the documentation of this file.

 
#ifndef OPMONLIB_INCLUDE_OPMONLIB_MONITORABLEOBJECT_HPP_
#define OPMONLIB_INCLUDE_OPMONLIB_MONITORABLEOBJECT_HPP_
 
#include "opmonlib/OpMonFacility.hpp"
#include "opmonlib/Utils.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 <map>
#include <memory>
#include <mutex>
#include <string>
#include <type_traits>
 
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_