componentMetrics.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_COMPONENTMETRICS_HPP
#define RTCTK_COMPONENTFRAMEWORK_COMPONENTMETRICS_HPP
 
#include <condition_variable>
#include <optional>
#include <thread>
 
#include <log4cplus/logger.h>
 
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/dataPointPath.hpp>
 
namespace rtctk::componentFramework {
 
class RepositoryIf;
class OldbIf;
 
class ComponentMetricsConfigurator {
public:
    ComponentMetricsConfigurator(std::weak_ptr<ComponentMetricsIf> service,
                                 std::shared_ptr<RepositoryIf> repo,
                                 DataPointPath root,
                                 log4cplus::Logger logger,
                                 std::chrono::seconds interval = std::chrono::seconds(10));
    ~ComponentMetricsConfigurator() noexcept;
 
private:
    void ConfigurationLoop();
 
    std::weak_ptr<ComponentMetricsIf> m_service;
    std::shared_ptr<RepositoryIf> m_repo;
    const DataPointPath m_root;
    const std::chrono::seconds m_interval;
 
    bool m_stop_flag;
    std::condition_variable m_cond;
    std::mutex m_mutex;
    std::thread m_thread;
    log4cplus::Logger m_logger;
};
 
class ComponentMetrics : public ComponentMetricsIf {
public:
    using ComponentMetricsIf::CounterTypes;
    using ComponentMetricsIf::CounterVariant;
 
    explicit ComponentMetrics(std::shared_ptr<OldbIf> oldb,
                              DataPointPath root,
                              log4cplus::Logger logger,
                              ComponentMetricsParams const& initial_params = {});
    ~ComponentMetrics() noexcept;
 
    void StartMonitoring() override;
    void StopMonitoring() noexcept override;
    bool IsMonitoring() noexcept override;
    void UpdateParams(ComponentMetricsParams const& params) override;
 
    [[nodiscard]] virtual perfc::ScopedRegistration
    AddCounter(CounterVariant counter, CounterMetricInfo info) override;
    bool RemoveCounter(CounterVariant counter) override;
 
    void AddThread(pid_t pid, ThreadMetricInfo info) override;
    void RemoveThread(pid_t thread) override;
 
    struct Thread {
        pid_t pid;
        ThreadMetricInfo info;
    };
 
private:
    struct Parameters {
        std::chrono::milliseconds counter_poll_interval = std::chrono::milliseconds(5000);
        std::chrono::milliseconds thread_poll_interval = std::chrono::milliseconds(5000);
        int thread_nice = 5;
    };
 
    struct MonitoringThread {
        MonitoringThread(std::thread t) : stop_flag(false), id(0), thread(std::move(t)) {
        }
        bool stop_flag;
        pid_t id;
        std::thread thread;
    };
 
    void MonitoringLoop();
 
    std::shared_ptr<OldbIf> m_oldb;
    DataPointPath m_root;
 
    std::recursive_mutex m_api_mtx;
 
    std::mutex m_mon_mtx;
 
    std::condition_variable m_cond;
 
    Parameters m_params;
 
    perfc::Register<CounterTypes, CounterMetricInfo> m_counters;
    std::vector<Thread> m_threads;
    std::optional<MonitoringThread> m_monitoring_thread;
    log4cplus::Logger m_logger;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_COMPONENTMETRICS_HPP