report_metric.cc

// report_metric.cc: Periodic Report Metric Plugin
// Author: Eric Flumerfelt
// Last Modified: 11/06/2014
//
// An implementation of the MetricPlugin for creating "Periodic Report" messages

#include "artdaq-utilities/Plugins/MetricMacros.hh"
#include "fhiclcpp/ParameterSet.h"

#include <fstream>
#include <ctime>
#include <string>
#include <sstream>
#include <mutex>
#include <sys/types.h>
#include <unistd.h>
#include "tracemf.h"

namespace artdaq
{
    class PeriodicReportMetric : public MetricPlugin
    {
    private:
      std::chrono::steady_clock::time_point last_report_time_;

      std::map<std::string, std::string> metrics_;

      std::mutex report_mutex_;
    public:
        explicit PeriodicReportMetric(fhicl::ParameterSet const& config, std::string const& app_name) : MetricPlugin(config, app_name)
                                                                                                      , last_report_time_(std::chrono::steady_clock::now())
                                                                                                      ,metrics_()
        {
            startMetrics();
        }

        virtual ~PeriodicReportMetric()
        {
            stopMetrics();
        }

        std::string getLibName() const override { return "report"; }

      void sendMetric_(const std::string& name, const std::string& value, const std::string& unit) override
      {
        if (!inhibit_)
          {
            metrics_[name] = value +  " " + unit;
            writeReportMessage_(false);
          }
      }

        void sendMetric_(const std::string& name, const int& value, const std::string& unit) override
        {
            sendMetric_(name, std::to_string(value), unit);
        }

        void sendMetric_(const std::string& name, const double& value, const std::string& unit) override
        {
            sendMetric_(name, std::to_string(value), unit);
        }

        void sendMetric_(const std::string& name, const float& value, const std::string& unit) override
        {
            sendMetric_(name, std::to_string(value), unit);
        }

        void sendMetric_(const std::string& name, const unsigned long int& value, const std::string& unit) override
        {
            sendMetric_(name, std::to_string(value), unit);
        }

        void startMetrics_() override
        {
        }

        void stopMetrics_() override
        {
          writeReportMessage_(true);
          metrics_.clear();
        }

    private:
      void writeReportMessage_(bool force)
      {
          std::unique_lock<std::mutex> lk(report_mutex_);
        if(force || std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(std::chrono::steady_clock::now() - last_report_time_).count() >= accumulationTime_)
          {
              if(metrics_.size() == 0) return;
            last_report_time_ = std::chrono::steady_clock::now();
            std::ostringstream str;

         int count = 0;
           int live_metrics = 0;
            for(auto& metric : metrics_)
              {
                if(count != 0) str << "," << std::endl;
                str << "\t" << metric.first << ": " << metric.second;
                if(metric.second != "NOT REPORTED") live_metrics++;
                metric.second = "NOT REPORTED";
                count++;
              }
            if(live_metrics > 0) TLOG_INFO(app_name_) << "Periodic report: " << live_metrics << " active metrics:"  << std::endl << str.str();
            else TLOG_INFO(app_name_) << "Periodic report: No active metrics in last reporting interval!";
          }
      }
    };
} //End namespace artdaq

DEFINE_ARTDAQ_METRIC(artdaq::PeriodicReportMetric)