dunedaq::opmonlib::OpMonManager Class Reference

#include <OpMonManager.hpp>

Inheritance diagram for dunedaq::opmonlib::OpMonManager:

Collaboration diagram for dunedaq::opmonlib::OpMonManager:

Public Member Functions
	OpMonManager (std::string session, std::string name, std::string opmon_facility_uri="stdout")
virtual	~OpMonManager ()=default
void	start_monitoring ()
void	set_opmon_conf (const confmodel::OpMonConf *c)
auto	get_opmon_id () const noexcept
auto	get_opmon_level () const noexcept
void	register_node (ElementId name, NewNodePtr)

Protected Member Functions
auto	get_opmon_facility () const
	OpMonManager (std::string session, std::string name, facility_ptr_t)
void	run (std::stop_token)
Protected Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	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 ()
	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
auto	get_opmon_level () const noexcept

Private Attributes
std::jthread	m_thread
std::atomic< const confmodel::OpMonConf * >	m_cfg {nullptr}

Friends
class	TestOpMonManager

Additional Inherited Members
Protected Types inherited from dunedaq::opmonlib::MonitorableObject
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string
Static Protected Member Functions inherited from dunedaq::opmonlib::MonitorableObject
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept

Detailed Description

Definition at line 49 of file OpMonManager.hpp.

Constructor & Destructor Documentation

OpMonManager() [1/2]

dunedaq::opmonlib::OpMonManager::OpMonManager ( std::string session, std::string name, std::string opmon_facility_uri = "stdout" )

inlineexplicit

Definition at line 60 of file OpMonManager.hpp.

                                                     :
    OpMonManager( session, name, makeOpMonFacility(opmon_facility_uri, make_origin(session, name)) ){;}

~OpMonManager()

virtual dunedaq::opmonlib::OpMonManager::~OpMonManager ( )

virtualdefault

OpMonManager() [2/2]

OpMonManager::OpMonManager ( std::string session, std::string name, facility_ptr_t f_ptr )

protected

Definition at line 16 of file OpMonManager.cpp.

  : MonitorableObject( name, session) {
 
  m_facility.store(f_ptr);
  
}

Member Function Documentation

get_opmon_facility()

auto dunedaq::opmonlib::OpMonManager::get_opmon_facility ( ) const

inlineprotected

Definition at line 87 of file OpMonManager.hpp.

{ return m_facility.load(); }

get_opmon_id()

auto dunedaq::opmonlib::MonitorableObject::get_opmon_id ( ) const

inlinenoexcept

Definition at line 93 of file MonitorableObject.hpp.

{ return m_parent_id + m_opmon_name; }

get_opmon_level()

auto dunedaq::opmonlib::MonitorableObject::get_opmon_level ( ) const

inlinenoexcept

Definition at line 95 of file MonitorableObject.hpp.

{ return m_opmon_level.load(); }

register_node()

void MonitorableObject::register_node	(	ElementId	name,
		NewNodePtr	p )

Append a register object to the chain The children will be modified using information from the this parent

Definition at line 113 of file MonitorableObject.cpp.

                                                                    {
 
  std::lock_guard<std::mutex> lock(m_node_mutex);
 
  // check if the name is already present to ensure uniqueness
  auto it = m_nodes.find(name) ;
  if ( it != m_nodes.end() ) {
    // This not desired because names are suppposed to be unique
    // But if the pointer is expired, there is no harm in override it
    if ( it -> second.expired() ) {
      ers::warning(NonUniqueNodeName(ERS_HERE, name, to_string(get_opmon_id())));
    }
    else {
      throw NonUniqueNodeName(ERS_HERE, name, to_string(get_opmon_id()));
    }
  }
  
  m_nodes[name] = p;
 
  p -> m_opmon_name = name;
  p -> inherit_parent_properties( *this );
 
  TLOG() << "Node " << name << " registered to " << to_string(get_opmon_id()) ;
}

run()

void OpMonManager::run ( std::stop_token stoken )

protected

Definition at line 42 of file OpMonManager.cpp.

                                            {
 
  auto sleep_interval = std::chrono::milliseconds(100);
  auto reporting_interval = m_cfg.load()->get_interval();  
  auto last_collection_time = std::chrono::steady_clock::now();
  
  while( ! stoken.stop_requested() ) {
    
    std::this_thread::sleep_for(sleep_interval);
    auto time_span = std::chrono::duration_cast<std::chrono::milliseconds>( std::chrono::steady_clock::now() - last_collection_time);
    
    if ( time_span >= reporting_interval ) {
      last_collection_time = std::chrono::steady_clock::now();
      publish( collect() );
      // there is no catch here because collect is supposed to catch all possible exceptions
      // In this way we should garantee the collection of metrics on the system
    }
  }
 
  TLOG() << "Exiting the monitoring thread";
}

set_opmon_conf()

void dunedaq::opmonlib::OpMonManager::set_opmon_conf ( const confmodel::OpMonConf * c )

inline

Definition at line 78 of file OpMonManager.hpp.

                                                     {
    m_cfg.store(c);
    set_opmon_level( m_cfg.load()->get_level() );
  }

start_monitoring()

void OpMonManager::start_monitoring

(

)

Definition at line 25 of file OpMonManager.cpp.

                                    {
 
  if ( ! m_cfg ) 
    throw MissingConfiguration(ERS_HERE);
 
  TLOG() << "Starting a new monitoring thread with interval " << m_cfg.load()->get_interval().count() << " seconds, at level " << get_opmon_level();
 
  auto running_function = std::bind( & OpMonManager::run, this, std::placeholders::_1);
  m_thread = std::jthread( running_function );
  auto handle = m_thread.native_handle();
  auto thread_name = "opmon";
  auto rc =  pthread_setname_np(handle, thread_name);    
   if (rc != 0) {
    ers::warning(ThreadNameTooLong(ERS_HERE, thread_name));
  }
}

Friends And Related Symbol Documentation

TestOpMonManager

friend class TestOpMonManager

friend

Definition at line 52 of file OpMonManager.hpp.

Member Data Documentation

m_cfg

std::atomic<const confmodel::OpMonConf*> dunedaq::opmonlib::OpMonManager::m_cfg {nullptr}

private

Definition at line 98 of file OpMonManager.hpp.

{nullptr}; 

m_thread

std::jthread dunedaq::opmonlib::OpMonManager::m_thread

private

Definition at line 97 of file OpMonManager.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/opmonlib/include/opmonlib/OpMonManager.hpp
• /github/workspace/dunedaq/sourcecode/opmonlib/src/OpMonManager.cpp