dunedaq::opmonlib Namespace Reference

Namespaces
namespace	opmon

Classes
class	BackendOpMonFacility
class	JSonOpMonFacility
class	MonitorableObject
class	NullOpMonFacility
class	OpMonFacility
class	OpMonLink
class	OpMonManager
class	TestOpMonManager

Typedefs
using	OpMonLevel
using	OptionalOrigin = std::optional<dunedaq::opmon::OpMonId>
using	CustomOrigin = std::map<std::string, std::string>
using	cr_map_type
using	map_type = std::remove_const<std::remove_reference<cr_map_type>::type>::type

Enumerations
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 }

Functions
template<class T >
constexpr auto	to_level (T v)
std::shared_ptr< OpMonFacility >	makeOpMonFacility (std::string const &facility, OptionalOrigin=OptionalOrigin())
template<class T >
void	set_value (google::protobuf::Message &m, const std::string &name, T value)
template<class T >
void	set_value (const google::protobuf::Reflection &, google::protobuf::Message &, const google::protobuf::FieldDescriptor *, T)
opmon::OpMonId	make_origin (const std::string &session, const std::string &app)
dunedaq::opmon::OpMonEntry	to_entry (const google::protobuf::Message &m, const CustomOrigin &co)
template<class M >
M	from_entry (const dunedaq::opmon::OpMonEntry &)
void	from_entry (google::protobuf::Message &m, const dunedaq::opmon::OpMonEntry &, std::string top_block="")
map_type	to_map (const google::protobuf::Message &m, std::string top_block="")
std::string	to_string (const dunedaq::opmon::OpMonId &)
const dunedaq::opmon::OpMonId &	operator+= (dunedaq::opmon::OpMonId &, const std::string &element)
dunedaq::opmon::OpMonId	operator+ (const dunedaq::opmon::OpMonId &, const std::string &element)

Typedef Documentation

cr_map_type

using dunedaq::opmonlib::cr_map_type

Initial value:

 std::invoke_result<decltype(&dunedaq::opmon::OpMonEntry::data),
                     dunedaq::opmon::OpMonEntry>::type

Definition at line 54 of file Utils.hpp.

CustomOrigin

using dunedaq::opmonlib::CustomOrigin = std::map<std::string, std::string>

Definition at line 53 of file Utils.hpp.

map_type

using dunedaq::opmonlib::map_type = std::remove_const<std::remove_reference<cr_map_type>::type>::type

Definition at line 56 of file Utils.hpp.

OpMonLevel

using dunedaq::opmonlib::OpMonLevel

Initial value:

 std::invoke_result<decltype(&dunedaq::confmodel::OpMonConf::get_level),
                    dunedaq::confmodel::OpMonConf>::type

Definition at line 52 of file MonitorableObject.hpp.

OptionalOrigin

using dunedaq::opmonlib::OptionalOrigin = std::optional<dunedaq::opmon::OpMonId>

Definition at line 84 of file OpMonFacility.hpp.

Enumeration Type Documentation

EntryOpMonLevel

enum class dunedaq::opmonlib::EntryOpMonLevel : OpMonLevel

strong

Enumerator
kTopPriority
kEventDriven
kDefault
kLowestPrioriry

Definition at line 60 of file MonitorableObject.hpp.

                             : 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
  };

SystemOpMonLevel

enum class dunedaq::opmonlib::SystemOpMonLevel : OpMonLevel

strong

Enumerator
kDisabled
kAll

Definition at line 55 of file MonitorableObject.hpp.

                              : OpMonLevel {
    kDisabled = std::numeric_limits<OpMonLevel>::min(),
    kAll      = std::numeric_limits<OpMonLevel>::max()
  };

Function Documentation

from_entry() [1/2]

template<class M >

M dunedaq::opmonlib::from_entry

(

const dunedaq::opmon::OpMonEntry &

e

)

Definition at line 2 of file Utils.hxx.

                                                               {
 
  M ret;
 
  if ( ret.GetTypeName() != e.measurement() ) {
    throw opmonlib::NameMismatch(ERS_HERE, ret.GetTypeName(), e.measurement());
  }
 
  from_entry(ret, e);
  
  return ret;
}

from_entry() [2/2]

void dunedaq::opmonlib::from_entry	(	google::protobuf::Message &	m,
		const dunedaq::opmon::OpMonEntry &	e,
		std::string	top_block = "" )

Definition at line 106 of file Utils.cpp.

                                         {
 
  const auto * descriptor_p = m.GetDescriptor();
  const auto & des = *descriptor_p;
  
  const auto * reflection_p = m.GetReflection();
  const auto & ref = *reflection_p;
  
  using namespace google::protobuf;
 
  auto count = des.field_count();
  for ( int i = 0; i < count; ++i ) {
    const auto * field_p = des.field(i);
    if ( field_p -> is_repeated() ) continue;
    
    auto name = top_block.empty() ? field_p -> name() : top_block + '.' + field_p -> name(); 
 
    auto type = field_p -> cpp_type();
 
    if ( type == FieldDescriptor::CppType::CPPTYPE_MESSAGE ) {
      auto message = ref.MutableMessage(&m, field_p);
      from_entry( *message, e, name );
    } else {
 
      auto value = e.data().find(name)->second;
 
      switch (type) {
      case FieldDescriptor::CppType::CPPTYPE_INT32:
    ref.SetInt32(&m, field_p, value.int4_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_INT64:
    ref.SetInt64(&m, field_p, value.int8_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_UINT32:
    ref.SetUInt32(&m, field_p, value.uint4_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_UINT64:
    ref.SetUInt64(&m, field_p, value.uint8_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_DOUBLE:
    ref.SetDouble(&m, field_p, value.double_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_FLOAT:
    ref.SetFloat(&m, field_p, value.float_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_BOOL:
    ref.SetBool(&m, field_p, value.boolean_value());
    break;
      case FieldDescriptor::CppType::CPPTYPE_STRING:
    ref.SetString(&m, field_p, value.string_value());
    break;
      default:
    break;
      } // switch on the cpp type                                                                         
    } // else if it's a message
  } // loop over the fields
 
}

make_origin()

dunedaq::opmon::OpMonId dunedaq::opmonlib::make_origin	(	const std::string &	session,
		const std::string &	app )

Definition at line 12 of file Utils.cpp.

                                                                                                   {
  opmon::OpMonId origin;
  origin.set_session( session );
  origin.set_application( app );
  return origin;
}

makeOpMonFacility()

std::shared_ptr< OpMonFacility > dunedaq::opmonlib::makeOpMonFacility	(	std::string const &	facility,
		OptionalOrigin	o = OptionalOrigin() )

Definition at line 14 of file OpMonFacility.cpp.

                                                                                                           {
 
  TLOG() << "FACILITY = " << facility;
 
  const std::string hook = "://";
  auto sep = facility.find(hook);
  std::string scheme;
  if (sep == std::string::npos) { // simple path   
    scheme = "stdout";
  } else { // with scheme 
    scheme = facility.substr(0, sep);
  }
 
  
  std::string plugin_name = scheme + "OpMonFacility";
  static cet::BasicPluginFactory bpf("duneOpMonFacility", "make");
  std::shared_ptr<OpMonFacility> os_ptr;
  
  try {
    os_ptr = bpf.makePlugin<std::shared_ptr<OpMonFacility>>(plugin_name, facility, o);
  } catch (const ers::Issue& iexpt) {
    throw OpMonFacilityCreationFailed(ERS_HERE, plugin_name, iexpt);
  } catch (const cet::exception& cexpt) {
    throw OpMonFacilityCreationFailedWithCause(ERS_HERE, plugin_name, cexpt.what());
  } catch (...) { // NOLINT JCF Jan-27-2021 violates letter of the law but not the spirit    
    throw OpMonFacilityCreationFailed(ERS_HERE, plugin_name);
  }
  return os_ptr;
}

operator+()

dunedaq::opmon::OpMonId dunedaq::opmonlib::operator+	(	const dunedaq::opmon::OpMonId &	id,
		const std::string &	element )

Definition at line 205 of file Utils.cpp.

                                                            {
 
  auto ret = id;
  ret += element;
  return ret;
}

operator+=()

const dunedaq::opmon::OpMonId & dunedaq::opmonlib::operator+=	(	dunedaq::opmon::OpMonId &	id,
		const std::string &	element )

Definition at line 185 of file Utils.cpp.

                                                            {
  
  if ( element.empty() ) return id;
  
  if ( id.session().empty() ) {
    id.set_session(element);
    return id;
  }
 
  if ( id.application().empty() ) {
    id.set_application(element);
    return id;
  }
 
  id.add_substructure(element);
  return id;
}

set_value() [1/2]

template<class T >

void dunedaq::opmonlib::set_value	(	const google::protobuf::Reflection &	,
		google::protobuf::Message &	,
		const google::protobuf::FieldDescriptor *	,
		T	)

set_value() [2/2]

template<class T >

void dunedaq::opmonlib::set_value	(	google::protobuf::Message &	m,
		const std::string &	name,
		T	value )

sets the field called "name" in the message m to the value of "value" This is essentially allows us to use any schema generated message as if it was dynamic object

Definition at line 17 of file Utils.hxx.

                                                                                          {
 
  const auto * descriptor_p = m.GetDescriptor();
  const auto & des = *descriptor_p;
 
  auto field_p = des.FindFieldByName(name);
  if ( ! field_p ) {
    throw MissingField(ERS_HERE, name, m.GetTypeName());
  }
 
  const auto * reflection_p = m.GetReflection();
  const auto & ref = *reflection_p;
 
  set_value( ref, m, field_p, value );
  
}

to_entry()

dunedaq::opmon::OpMonEntry dunedaq::opmonlib::to_entry	(	const google::protobuf::Message &	m,
		const CustomOrigin &	co )

Definition at line 20 of file Utils.cpp.

                                                        {
 
  dunedaq::opmon::OpMonEntry entry;
  entry.set_measurement( m.GetTypeName() );
 
  *entry.mutable_data() = dunedaq::opmonlib::to_map(m);
  
  for ( const auto & [tag, value] : co ) {
    (*entry.mutable_custom_origin())[tag] = value;
  }
  
  return entry;
}

to_level()

template<class T >

auto dunedaq::opmonlib::to_level ( T v )

constexpr

Definition at line 68 of file MonitorableObject.hpp.

                                 {
    return static_cast<typename std::underlying_type<T>::type>(v);
  }

to_map()

dunedaq::opmonlib::map_type dunedaq::opmonlib::to_map	(	const google::protobuf::Message &	m,
		std::string	top_block = "" )

Definition at line 36 of file Utils.cpp.

                                                    {
 
  dunedaq::opmonlib::map_type ret;
 
  const auto * descriptor_p = m.GetDescriptor();
  const auto & des = *descriptor_p;
  
  const auto * reflection_p = m.GetReflection();
  const auto & ref = *reflection_p;
  
  using namespace google::protobuf;
 
  auto count = des.field_count();
  for ( int i = 0; i < count; ++i ) {
    const auto * field_p = des.field(i);
    if ( field_p -> is_repeated() ) continue;
    
    auto name = top_block.empty() ? field_p -> name() : top_block + '.' + field_p -> name(); 
 
    auto type = field_p -> cpp_type();
    dunedaq::opmon::OpMonValue value;
    bool success = true;
    switch (type) {
    case FieldDescriptor::CppType::CPPTYPE_INT32:
      value.set_int4_value( ref.GetInt32(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_INT64:
      value.set_int8_value( ref.GetInt64(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_UINT32:
      value.set_uint4_value( ref.GetUInt32(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_UINT64:
      value.set_uint8_value( ref.GetUInt64(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_DOUBLE:
      value.set_double_value( ref.GetDouble(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_FLOAT:
      value.set_float_value( ref.GetFloat(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_BOOL:
      value.set_boolean_value( ref.GetBool(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_STRING:
      value.set_string_value( ref.GetString(m, field_p) );
      break;
    case FieldDescriptor::CppType::CPPTYPE_MESSAGE:
      {
    auto data = dunedaq::opmonlib::to_map(ref.GetMessage(m, field_p), name);
    ret.insert(data.begin(), data.end());
    success = false;
    break;
      }
    default:
      success = false;
      break;
    } // switch on the cpp type                                                                         
 
      
    if ( success )
      ret[name] = value;
  }
 
  return ret;
  
}

to_string()

std::string dunedaq::opmonlib::to_string

(

const dunedaq::opmon::OpMonId &

id

)

Definition at line 167 of file Utils.cpp.

                                                                     {
 
  std::string ret(id.session());
 
  if ( ! id.application().empty() ) {
    ret += '.';
    ret += id.application();
  }
  
  for( int i = 0; i < id.substructure().size(); ++i ) {
    ret += '.';
    ret += id.substructure()[i];
  }
 
  return ret;
}