dunedaq::opmonlib::MonitorableObject Class Reference

#include <MonitorableObject.hpp>

Inheritance diagram for dunedaq::opmonlib::MonitorableObject:

Collaboration diagram for dunedaq::opmonlib::MonitorableObject:

Public Types
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string

Public Member Functions
	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

Static Public Member Functions
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept

Protected Member Functions
	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 ()

Private Types
using	facility_ptr_t = std::shared_ptr<opmonlib::OpMonFacility>
using	const_metric_counter_t
using	metric_counter_t = std::remove_const<const_metric_counter_t>::type
using	const_time_counter_t
using	time_counter_t = std::remove_const<const_metric_counter_t>::type

Private Member Functions
opmon::MonitoringTreeInfo	collect () noexcept
void	set_opmon_level (OpMonLevel) noexcept
void	inherit_parent_properties (const MonitorableObject &parent)
	MonitorableObject (ElementId name, ElementId parent_id="")

Private Attributes
std::map< ElementId, NodePtr >	m_nodes
std::mutex	m_node_mutex
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
std::atomic< metric_counter_t >	m_published_counter {0}
std::atomic< metric_counter_t >	m_ignored_counter {0}
std::atomic< metric_counter_t >	m_error_counter {0}
std::atomic< time_counter_t >	m_cpu_us_counter {0}

Static Private Attributes
static facility_ptr_t	s_default_facility = std::make_shared<NullOpMonFacility>()

Friends
class	OpMonManager

Detailed Description

Definition at line 73 of file MonitorableObject.hpp.

Member Typedef Documentation

const_metric_counter_t

using dunedaq::opmonlib::MonitorableObject::const_metric_counter_t

private

Initial value:

 std::invoke_result<decltype(&dunedaq::opmonlib::opmon::MonitoringTreeInfo::n_published_measurements),
                            dunedaq::opmonlib::opmon::MonitoringTreeInfo>::type

Definition at line 179 of file MonitorableObject.hpp.

const_time_counter_t

using dunedaq::opmonlib::MonitorableObject::const_time_counter_t

private

Initial value:

 std::invoke_result<decltype(&dunedaq::opmonlib::opmon::MonitoringTreeInfo::cpu_elapsed_time_us),
                          dunedaq::opmonlib::opmon::MonitoringTreeInfo>::type

Definition at line 186 of file MonitorableObject.hpp.

ElementId

using dunedaq::opmonlib::MonitorableObject::ElementId = std::string

Definition at line 79 of file MonitorableObject.hpp.

facility_ptr_t

using dunedaq::opmonlib::MonitorableObject::facility_ptr_t = std::shared_ptr<opmonlib::OpMonFacility>

private

Definition at line 170 of file MonitorableObject.hpp.

metric_counter_t

using dunedaq::opmonlib::MonitorableObject::metric_counter_t = std::remove_const<const_metric_counter_t>::type

private

Definition at line 181 of file MonitorableObject.hpp.

NewNodePtr

using dunedaq::opmonlib::MonitorableObject::NewNodePtr = std::shared_ptr<MonitorableObject>

Definition at line 78 of file MonitorableObject.hpp.

NodePtr

using dunedaq::opmonlib::MonitorableObject::NodePtr = std::weak_ptr<MonitorableObject>

Definition at line 77 of file MonitorableObject.hpp.

time_counter_t

using dunedaq::opmonlib::MonitorableObject::time_counter_t = std::remove_const<const_metric_counter_t>::type

private

Definition at line 188 of file MonitorableObject.hpp.

Constructor & Destructor Documentation

MonitorableObject() [1/4]

dunedaq::opmonlib::MonitorableObject::MonitorableObject ( const MonitorableObject & )

delete

copy and move constructors are deleted as they violate the linking chain

MonitorableObject() [2/4]

dunedaq::opmonlib::MonitorableObject::MonitorableObject ( MonitorableObject && )

delete

~MonitorableObject()

virtual dunedaq::opmonlib::MonitorableObject::~MonitorableObject ( )

virtualdefault

MonitorableObject() [3/4]

dunedaq::opmonlib::MonitorableObject::MonitorableObject ( )

protecteddefault

default constructors are ok as they set the links correctly i.e. The service points to the null and the names are not set

MonitorableObject() [4/4]

dunedaq::opmonlib::MonitorableObject::MonitorableObject ( ElementId name, ElementId parent_id = "" )

inlineprivate

Contructor to set initial strings

Definition at line 161 of file MonitorableObject.hpp.

    : m_parent_id()
    , m_opmon_name(name) {
    m_parent_id.set_session(parent_id);
  }

Member Function Documentation

collect()

opmon::MonitoringTreeInfo MonitorableObject::collect ( )

privatenoexcept

Instructs the object to pusblish regular interval metrics. It also instruct the children to execute their collect methods.

Returns

It returns a protobuf schema object to monitor the tree

Definition at line 101 of file MonitorableObject.cpp.

                                                            {
 
  auto start_time = std::chrono::high_resolution_clock::now();
 
  TLOG_DEBUG(TLVL_MONITORING_STEPS) << "Collecting data from " << to_string(get_opmon_id());
  
  opmon::MonitoringTreeInfo info;
 
  info.set_n_invalid_links(0);
 
  try {
    generate_opmon_data();
  } catch ( const ers::Issue & i ) {
    ++m_error_counter;
    auto cause_ptr = i.cause();
    while ( cause_ptr ) {
      ++m_error_counter;
      cause_ptr = cause_ptr->cause();
    }
    ers::error( ErrorWhileCollecting(ERS_HERE, to_string(get_opmon_id()), i) );
  } catch (  const std::exception & e ) {
    ++m_error_counter;
    ers::error( ErrorWhileCollecting(ERS_HERE, to_string(get_opmon_id()), e) );
  } catch (...) {
    ++m_error_counter;
    ers::error( ErrorWhileCollecting(ERS_HERE, to_string(get_opmon_id())) );
  }
 
  info.set_n_published_measurements( m_published_counter.exchange(0) );
  info.set_n_ignored_measurements( m_ignored_counter.exchange(0) );
  info.set_n_errors( m_error_counter.exchange(0) );
  if (info.n_published_measurements() > 0) {
    info.set_n_publishing_nodes(1);
  }
  info.set_cpu_elapsed_time_us( m_cpu_us_counter.exchange(0) ); 
 
 
  std::lock_guard<std::mutex> lock(m_node_mutex);
 
  info.set_n_registered_nodes( m_nodes.size() );
 
  unsigned int n_invalid_links = 0;
  
  for ( auto it = m_nodes.begin(); it != m_nodes.end(); ) {
 
    auto ptr = it->second.lock();
    
    if( ptr ) {
      auto child_info = ptr->collect();  // MR: can we make this an async? There is no point to wait all done here
      info.set_n_registered_nodes( info.n_registered_nodes() + child_info.n_registered_nodes() );
      info.set_n_publishing_nodes( info.n_publishing_nodes() + child_info.n_publishing_nodes() );
      info.set_n_invalid_links( info.n_invalid_links() + child_info.n_invalid_links() );
      info.set_n_published_measurements( info.n_published_measurements() + child_info.n_published_measurements() );
      info.set_n_ignored_measurements( info.n_ignored_measurements() + child_info.n_ignored_measurements() );
      info.set_n_errors( info.n_errors() + child_info.n_errors() );
      info.set_cpu_elapsed_time_us( info.cpu_elapsed_time_us() + child_info.cpu_elapsed_time_us() );
    }
 
    // prune the dead links
    if ( it->second.expired() ) {
      it = m_nodes.erase(it);
      ++n_invalid_links;
    } else {
      ++it;
    }
  }
 
  info.set_n_invalid_links( info.n_invalid_links() + n_invalid_links );
  
  
  auto stop_time = std::chrono::high_resolution_clock::now();
 
  auto duration = std::chrono::duration_cast<std::chrono::microseconds>( stop_time - start_time );
  info.set_clockwall_elapsed_time_us( duration.count() );
  
  return info;
}

generate_opmon_data()

virtual void dunedaq::opmonlib::MonitorableObject::generate_opmon_data ( )

inlineprotectedvirtual

Hook for customisable pubblication. The function can throw, exception will be caught by the monitoring thread

Reimplemented in dunedaq::asiolibs::SourceModel< TargetPayloadType >, dunedaq::crtmodules::SourceModel< TargetPayloadType >, dunedaq::datahandlinglibs::DataHandlingModel< ReadoutType, RequestHandlerType, LatencyBufferType, RawDataProcessorType, InputDataType >, dunedaq::datahandlinglibs::DataSubscriberModel< PayloadType >, dunedaq::datahandlinglibs::DefaultRequestHandlerModel< ReadoutType, LatencyBufferType >, dunedaq::datahandlinglibs::DefaultRequestHandlerModel< T, datahandlinglibs::SkipListLatencyBufferModel< T > >, dunedaq::datahandlinglibs::DefaultRequestHandlerModel< TriggerPrimitiveTypeAdapter, datahandlinglibs::SkipListLatencyBufferModel< TriggerPrimitiveTypeAdapter > >, dunedaq::datahandlinglibs::DefaultRequestHandlerModel< types::DAPHNESuperChunkTypeAdapter, datahandlinglibs::SkipListLatencyBufferModel< types::DAPHNESuperChunkTypeAdapter > >, dunedaq::datahandlinglibs::IterableQueueModel< T >, dunedaq::datahandlinglibs::SkipListLatencyBufferModel< T >, dunedaq::datahandlinglibs::SourceEmulatorModel< ReadoutType >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< ReadoutType >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< hsilibs::HSI_FRAME_STRUCT >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TAWrapper >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TCWrapper >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< TriggerPrimitiveTypeAdapter >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::CRTBernTypeAdapter >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::CRTGrenobleTypeAdapter >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::DAPHNEStreamSuperChunkTypeAdapter >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::DUNEWIBEthTypeAdapter >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::TDEEthTypeAdapter >, dunedaq::datahandlinglibs::TaskRawDataProcessorModel< types::TDEFrameTypeAdapter >, dunedaq::dpdklibs::SourceModel< TargetPayloadType >, dunedaq::fdreadoutlibs::TDEEthFrameProcessor, dunedaq::fdreadoutlibs::WIBEthFrameProcessor, dunedaq::flxlibs::CardControllerWrapper, dunedaq::flxlibs::ElinkModel< TargetPayloadType >, dunedaq::iomanager::QueueBase, dunedaq::ipm::Receiver, dunedaq::ipm::Sender, dunedaq::trigger::HSISourceModel, dunedaq::trigger::TAProcessor, dunedaq::trigger::TCProcessor, and dunedaq::trigger::TPProcessor.

Definition at line 135 of file MonitorableObject.hpp.

{return;}

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(); }

inherit_parent_properties()

void MonitorableObject::inherit_parent_properties ( const MonitorableObject & parent )

private

utilities for linking with parent and top levels

Definition at line 193 of file MonitorableObject.cpp.

                                                                                    {
 
  m_facility.store(parent.m_facility);
  m_parent_id = parent.get_opmon_id();
  m_opmon_level = parent.get_opmon_level();
  
  std::lock_guard<std::mutex> lock(m_node_mutex);
 
  for ( const auto & [key,wp] : m_nodes ) {
 
    auto p = wp.lock();
    if ( p ) {
      p->inherit_parent_properties(*this);
    }
    
  }
  
}

operator=() [1/2]

MonitorableObject & dunedaq::opmonlib::MonitorableObject::operator= ( const MonitorableObject & )

delete

operator=() [2/2]

MonitorableObject & dunedaq::opmonlib::MonitorableObject::operator= ( MonitorableObject && )

delete

publish()

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

protectednoexcept

Convert the message into an OpMonEntry and then uses the pointer to the Facility to publish the entry. This also timestamps the message with the time of the invocation. It is possible to associate an element name to the published message. the element name is checked against the children to protect uniqueness. It is also possible to associate a custom origin in the form of a map<string,string>. This is designed to add information which is independent from the software structure e.g. channels or other hardware information. Messages will have an associated OpmonLevel that is used to suppress the pubblication of metrics. The level of the message is set by the OpMonManager.

Definition at line 58 of file MonitorableObject.cpp.

                                               {
 
  auto timestamp = google::protobuf::util::TimeUtil::GetCurrentTime();
 
  auto start_time = std::chrono::high_resolution_clock::now();
  
  if ( ! MonitorableObject::publishable_metric( l, get_opmon_level() ) ) {
    TLOG_DEBUG(TLVL_LEVEL_SUPPRESSION) << "Metric " << m.GetTypeName() << " ignored because of the level";
    ++m_ignored_counter;
    return;
  }
  
  auto e = to_entry( m, co );
 
  if ( e.data().empty() ) {
    ers::warning( EntryWithNoData(ERS_HERE, e.measurement() ) );
    return ;
  }
 
  *e.mutable_origin() = get_opmon_id() ;
  
  *e.mutable_time() = timestamp;
 
  // this pointer is always garanteed to be filled, even if with a null Facility.
  // But the facility can fail
  try {
    m_facility.load()->publish(std::move(e));
    ++m_published_counter;
  } catch ( const OpMonPublishFailure & e ) {
    ers::error(e);
    ++m_error_counter;
  }
  
  auto stop_time = std::chrono::high_resolution_clock::now();
 
  auto duration = std::chrono::duration_cast<std::chrono::microseconds>( stop_time - start_time );
  m_cpu_us_counter += duration.count();
 
}

publishable_metric()

static bool dunedaq::opmonlib::MonitorableObject::publishable_metric ( OpMonLevel entry, OpMonLevel system )

inlinestaticnoexcept

Definition at line 97 of file MonitorableObject.hpp.

                                                                                 {
    return (entry < system);
  }

register_node()

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

protected

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

Definition at line 32 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()) ;
}

set_opmon_level()

void MonitorableObject::set_opmon_level ( OpMonLevel l )

privatenoexcept

Hook to propagate the OpMonLevel at lower levels of the monitoring tree

Definition at line 180 of file MonitorableObject.cpp.

                                                               {
 
  m_opmon_level = l;
 
  std::lock_guard<std::mutex> lock(m_node_mutex);
  for ( const auto & [key,wp] : m_nodes ) {
    auto p = wp.lock();
    if (p) {
      p->set_opmon_level(l);
    }
  }
}

Friends And Related Symbol Documentation

OpMonManager

friend class OpMonManager

friend

Definition at line 81 of file MonitorableObject.hpp.

Member Data Documentation

m_cpu_us_counter

std::atomic<time_counter_t> dunedaq::opmonlib::MonitorableObject::m_cpu_us_counter {0}

mutableprivate

Definition at line 189 of file MonitorableObject.hpp.

{0};

m_error_counter

std::atomic<metric_counter_t> dunedaq::opmonlib::MonitorableObject::m_error_counter {0}

mutableprivate

Definition at line 184 of file MonitorableObject.hpp.

{0};

m_facility

std::atomic<facility_ptr_t> dunedaq::opmonlib::MonitorableObject::m_facility {s_default_facility}

private

Definition at line 171 of file MonitorableObject.hpp.

{s_default_facility};

m_ignored_counter

std::atomic<metric_counter_t> dunedaq::opmonlib::MonitorableObject::m_ignored_counter {0}

mutableprivate

Definition at line 183 of file MonitorableObject.hpp.

{0};

m_node_mutex

std::mutex dunedaq::opmonlib::MonitorableObject::m_node_mutex

private

Definition at line 168 of file MonitorableObject.hpp.

m_nodes

std::map<ElementId, NodePtr> dunedaq::opmonlib::MonitorableObject::m_nodes

private

Definition at line 167 of file MonitorableObject.hpp.

m_opmon_level

std::atomic<OpMonLevel> dunedaq::opmonlib::MonitorableObject::m_opmon_level = to_level(SystemOpMonLevel::kAll)

private

Definition at line 173 of file MonitorableObject.hpp.

m_opmon_name

ElementId dunedaq::opmonlib::MonitorableObject::m_opmon_name

private

Definition at line 174 of file MonitorableObject.hpp.

m_parent_id

dunedaq::opmon::OpMonId dunedaq::opmonlib::MonitorableObject::m_parent_id

private

Definition at line 172 of file MonitorableObject.hpp.

m_published_counter

std::atomic<metric_counter_t> dunedaq::opmonlib::MonitorableObject::m_published_counter {0}

mutableprivate

Definition at line 182 of file MonitorableObject.hpp.

{0};

s_default_facility

std::shared_ptr< OpMonFacility > MonitorableObject::s_default_facility = std::make_shared<NullOpMonFacility>()

staticprivate

Definition at line 176 of file MonitorableObject.hpp.

---

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

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