MetricManager.hh

#ifndef artdaq_DAQrate_MetricManager_hh
#define artdaq_DAQrate_MetricManager_hh

// MetricManager class definition file
// Author: Eric Flumerfelt
// Last Modified: 11/14/2014
//
// MetricManager loads a user-specified set of plugins, sends them their configuration,
// and sends them data as it is recieved. It also maintains the state of the plugins
// relative to the application state.

#include "artdaq-utilities/Plugins/MetricData.hh"
#include "artdaq-utilities/Plugins/MetricPlugin.hh"
#include "fhiclcpp/fwd.h"
#include "fhiclcpp/types/OptionalTable.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include <atomic>
#include <boost/thread.hpp>
#include <condition_variable>
#include <queue>
#include <sstream>

namespace artdaq {
    class MetricManager;
}

class artdaq::MetricManager {
public:
  struct Config {
    fhicl::Atom<size_t> metric_queue_size{
        fhicl::Name{"metric_queue_size"},
        fhicl::Comment{"The maximum number of metric entries which can be stored in the metric queue."}, 1000};
    fhicl::Atom<size_t> metric_queue_notify_size{
        fhicl::Name{"metric_queue_notify_size"},
        fhicl::Comment{
            "The number of metric entries in the list which will cause reports of the queue size to be printed."},
        10};
    fhicl::Atom<int> metric_send_maximum_delay_ms{
        fhicl::Name{"metric_send_maximum_delay_ms"},
        fhicl::Comment{"The maximum amount of time between metric send calls (will send 0s for metrics which have not "
                       "reported in this interval)"},
        15000};
        fhicl::OptionalTable<artdaq::MetricPlugin::Config> metricConfig{ fhicl::Name{"metricConfig"} };
    };
    using Parameters = fhicl::WrappedTable<Config>;

    MetricManager();

    MetricManager(MetricManager const&) = delete;

    virtual ~MetricManager() noexcept;

    MetricManager& operator=(MetricManager const&) = delete;

    void initialize(fhicl::ParameterSet const& pset, std::string const& prefix = "");

    void do_start();

    void do_stop();

    void do_pause();

    void do_resume();

    void reinitialize(fhicl::ParameterSet const& pset, std::string const& prefix = "");

    void shutdown();

  void sendMetric(std::string const& name, std::string const& value, std::string const& unit, int level,
                  MetricMode mode, std::string const& metricPrefix = "", bool useNameOverride = false);

  void sendMetric(std::string const& name, int const& value, std::string const& unit, int level, MetricMode mode,
                  std::string const& metricPrefix = "", bool useNameOverride = false);

  void sendMetric(std::string const& name, double const& value, std::string const& unit, int level, MetricMode mode,
                  std::string const& metricPrefix = "", bool useNameOverride = false);

  void sendMetric(std::string const& name, float const& value, std::string const& unit, int level, MetricMode mode,
                  std::string const& metricPrefix = "", bool useNameOverride = false);

  void sendMetric(std::string const& name, long unsigned int const& value, std::string const& unit, int level,
                  MetricMode mode, std::string const& metricPrefix = "", bool useNameOverride = false);

    void setPrefix(std::string const& prefix) { prefix_ = prefix; }

    bool Initialized() { return initialized_; }

    bool Running() { return running_; }

    bool Active() { return active_; }

    bool metricQueueEmpty();

    size_t metricQueueSize(std::string const& name = "");

private:
    void sendMetricLoop_();

    void startMetricLoop_();

    std::vector<std::unique_ptr<artdaq::MetricPlugin>> metric_plugins_;
    boost::thread metric_sending_thread_;
    std::mutex metric_mutex_;
    std::condition_variable metric_cv_;
    int metric_send_interval_ms_;

    std::atomic<bool> initialized_;
    std::atomic<bool> running_;
    std::atomic<bool> active_;
    std::string prefix_;

  std::unordered_map<std::string, std::unique_ptr<MetricData>> metric_cache_;
  std::mutex metric_cache_mutex_;
    std::atomic<size_t> missed_metric_calls_;
  std::atomic<size_t> metric_calls_;
  size_t metric_cache_max_size_;
  size_t metric_cache_notify_size_;
};

#endif /* artdaq_DAQrate_MetricManager_hh */