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 = std::invoke_result<decltype(&dunedaq::opmon::OpMonEntry::data), dunedaq::opmon::OpMonEntry>::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 = std::invoke_result<decltype(&dunedaq::opmon::OpMonEntry::data), dunedaq::opmon::OpMonEntry>::type

Definition at line 47 of file Utils.hpp.

CustomOrigin

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

Definition at line 46 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 48 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 46 of file MonitorableObject.hpp.

OptionalOrigin

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

Definition at line 86 of file OpMonFacility.hpp.

Enumeration Type Documentation

EntryOpMonLevel

enum class dunedaq::opmonlib::EntryOpMonLevel : OpMonLevel

strong

Enumerator
kTopPriority
kEventDriven
kDefault
kLowestPrioriry

Definition at line 55 of file MonitorableObject.hpp.

{
  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 49 of file MonitorableObject.hpp.

{
  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 3 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 105 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 15 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 206 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 19 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 21 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 65 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 37 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 166 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;
}