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 "artdaq-utilities/Plugins/SystemMetricCollector.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::Atom<bool> send_system_metrics{fhicl::Name{"send_system_metrics"}, fhicl::Comment{"Whether to collect and send system metrics such as CPU usage, Memory usage and network activity."}, false};
        fhicl::Atom<bool> send_process_metrics{fhicl::Name{"send_process_metrics"}, fhicl::Comment{"Whether to collect and send process CPU usage and Memory usage"}, false};
        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::unique_ptr<SystemMetricCollector> system_metric_collector_;

    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 */