pcpmmv_metric.cc

// PCPMMV_metric.cc: PCPMMV Metric Plugin
// Author: Eric Flumerfelt
// Last Modified: 3/22/2019
//
// An implementation of the MetricPlugin interface for PCPMMV

#ifndef __PCPMMV_METRIC__
#define __PCPMMV_METRIC__ 1

#define TRACE_NAME "PCPMMVMetric"
#include "tracemf.h"

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

// pmapi.h must be included before mmv_stats.h
#include <pcp/pmapi.h>

#include <pcp/mmv_stats.h>

#include <utility>

namespace artdaq {
class PCPMMVMetric final : public MetricPlugin
{
private:
    std::unordered_map<std::string, int> registered_metric_types_;
    std::vector<mmv_metric_t> registered_metrics_;

    void* mmvAddr_;
    int domain_;

    size_t initial_metric_collection_time_;
    std::chrono::steady_clock::time_point metric_start_time_;

    void copy_string(char* dest, size_t dstsize, const std::string& src)
    {
        if (src.size() <= dstsize - 1)
        {
            dstsize = src.size() + 1;
        }
        memcpy(dest, src.c_str(), dstsize);
    }

    void init_mmv()
    {
        if (!registered_metrics_.empty())
        {
            mmv_stats_flags_t flags{};
            TLOG(TLVL_INFO) << "Going to initialize mmv metric with name " << normalize_name_(app_name_) << ", metric count " << registered_metrics_.size();
            TLOG(TLVL_INFO) << "First metric name: " << registered_metrics_[0].name << ", type " << registered_metrics_[0].type << ", item " << registered_metrics_[0].item;
            mmvAddr_ = mmv_stats_init(normalize_name_(app_name_).c_str(), domain_, flags, &registered_metrics_[0], registered_metrics_.size(), nullptr, 0);
        }
    }

    void stop_mmv()
    {
        if (mmvAddr_ != nullptr)
        {
            mmv_stats_stop(normalize_name_(app_name_).c_str(), mmvAddr_);
            mmvAddr_ = nullptr;
        }
    }

    std::string normalize_name_(std::string name)
    {
        auto nameTemp(std::move(name));

        auto pos = nameTemp.find('%');
        while (pos != std::string::npos)
        {
            nameTemp = nameTemp.replace(pos, 1, "Percent");
            pos = nameTemp.find('%');
        }
        std::replace(nameTemp.begin(), nameTemp.end(), ' ', '_');

        if (nameTemp.size() > MMV_NAMEMAX - 1)
        {
            nameTemp = nameTemp.substr(0, MMV_NAMEMAX - 1);
        }
        return nameTemp;
    }

    bool check_time_()
    {
        auto dur = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - metric_start_time_).count();
        TLOG(TLVL_INFO) << "Duration since start: " << dur << " seconds. (initial = " << initial_metric_collection_time_ << " seconds)";
        if (dur < 0)
        {
            return false;
        }
        return static_cast<size_t>(dur) > initial_metric_collection_time_;
    }

    pmUnits infer_units_(std::string unitString)
    {
        pmUnits output;
        output.scaleCount = PM_COUNT_ONE;
        output.scaleSpace = PM_SPACE_BYTE;
        output.scaleTime = PM_TIME_SEC;
        output.dimTime = 0;
        output.dimSpace = 0;
        output.dimCount = 0;

        std::transform(unitString.begin(), unitString.end(), unitString.begin(), ::tolower);
        std::string before = unitString;
        std::string after;

        if (auto pos = unitString.find('/') != std::string::npos)
        {
            before = unitString.substr(0, static_cast<int>(pos) - 1);
            after = unitString.substr(pos);
        }
        std::istringstream iss(before);
        std::vector<std::string> before_tokens{std::istream_iterator<std::string>{iss},
                                               std::istream_iterator<std::string>{}};

        iss.str(after);
        std::vector<std::string> after_tokens{std::istream_iterator<std::string>{iss},
                                              std::istream_iterator<std::string>{}};

        for (const auto& token : before_tokens)
        {
            if (token.empty())
            {
                continue;
            }
            if (token == "s" || token.find("sec") == 0)
            {
                output.dimTime++;
            }
            else if (token == "b" || token.find("byte") == 0)
            {
                output.dimSpace++;
            }
            else
            {
                output.dimCount++;
            }
        }

        for (const auto& token : after_tokens)
        {
            if (token.empty())
            {
                continue;
            }
            if (token == "s" || token.find("sec") == 0)
            {
                output.dimTime--;
            }
            else if (token == "b" || token.find("byte") == 0)
            {
                output.dimSpace--;
            }
            else
            {
                output.dimCount--;
            }
        }

        return output;
    }

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

public:
    explicit PCPMMVMetric(fhicl::ParameterSet const& pset, std::string const& app_name)
        : MetricPlugin(pset, app_name)
        , mmvAddr_(nullptr)
        , domain_(pset.get<int>("pcp_domain_number", 0))
        , initial_metric_collection_time_(pset.get<size_t>("seconds_before_init", 30))
    {}

    ~PCPMMVMetric() override { MetricPlugin::stopMetrics(); }

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

    void stopMetrics_() override {}

    void startMetrics_() override { metric_start_time_ = std::chrono::steady_clock::now(); }

    void sendMetric_(const std::string& name, const std::string& value, const std::string& unit, const std::chrono::system_clock::time_point&) override
    {
        auto nname = normalize_name_(name);
        if (registered_metric_types_.count(nname) == 0u)
        {
            TLOG(TLVL_INFO) << "Adding string metric named " << nname;
            mmv_metric_t newMetric;
            copy_string(newMetric.name, MMV_NAMEMAX, nname);
            newMetric.item = registered_metrics_.size();
            newMetric.type = MMV_TYPE_STRING;
            newMetric.semantics = MMV_SEM_INSTANT;
            newMetric.dimension = infer_units_(unit);
            newMetric.indom = 0;
            newMetric.helptext = nullptr;
            newMetric.shorttext = nullptr;

            registered_metrics_.push_back(newMetric);
            registered_metric_types_[nname] = MMV_TYPE_STRING;
            stop_mmv();
        }

        if (registered_metric_types_[nname] != MMV_TYPE_STRING)
        {
            TLOG(TLVL_ERROR) << "PCP-MMV Metric: Metric instance has wrong type! Expected " << registered_metric_types_[nname]
                             << ", got std::string";
            return;
        }

        if ((mmvAddr_ == nullptr) && check_time_())
        {
            init_mmv();
        }

        if (mmvAddr_ != nullptr)
        {
            auto base = mmv_lookup_value_desc(mmvAddr_, nname.c_str(), nullptr);
            auto val = value;
            if (val.size() > MMV_STRINGMAX - 1)
            {
                val = val.substr(0, MMV_STRINGMAX - 1);
            }

            mmv_set_string(mmvAddr_, base, value.c_str(), value.size());
        }
    }

    void sendMetric_(const std::string& name, const int& value, const std::string& unit, const std::chrono::system_clock::time_point&) override
    {
        auto nname = normalize_name_(name);
        if (registered_metric_types_.count(nname) == 0u)
        {
            TLOG(TLVL_INFO) << "Adding int metric named " << nname;
            mmv_metric_t newMetric;
            copy_string(newMetric.name, MMV_NAMEMAX, nname);
            newMetric.item = registered_metrics_.size();
            newMetric.type = MMV_TYPE_I64;
            newMetric.semantics = MMV_SEM_INSTANT;
            newMetric.dimension = infer_units_(unit);
            newMetric.indom = 0;
            newMetric.helptext = nullptr;
            newMetric.shorttext = nullptr;

            registered_metrics_.push_back(newMetric);
            registered_metric_types_[nname] = MMV_TYPE_I64;
            stop_mmv();
        }

        if (registered_metric_types_[nname] != MMV_TYPE_I64)
        {
            TLOG(TLVL_ERROR) << "PCP-MMV Metric: Metric instance has wrong type! Expected " << registered_metric_types_[nname]
                             << ", got int";
            return;
        }

        if ((mmvAddr_ == nullptr) && check_time_())
        {
            init_mmv();
        }

        if (mmvAddr_ != nullptr)
        {
            auto base = mmv_lookup_value_desc(mmvAddr_, nname.c_str(), nullptr);
            mmv_set_value(mmvAddr_, base, value);
        }
    }

    void sendMetric_(const std::string& name, const double& value, const std::string& unit, const std::chrono::system_clock::time_point&) override
    {
        auto nname = normalize_name_(name);
        if (registered_metric_types_.count(nname) == 0u)
        {
            TLOG(TLVL_INFO) << "Adding double metric named " << nname;
            mmv_metric_t newMetric;
            copy_string(newMetric.name, MMV_NAMEMAX, nname);
            newMetric.item = registered_metrics_.size();
            newMetric.type = MMV_TYPE_DOUBLE;
            newMetric.semantics = MMV_SEM_INSTANT;
            newMetric.dimension = infer_units_(unit);
            newMetric.indom = 0;
            newMetric.helptext = nullptr;
            newMetric.shorttext = nullptr;

            registered_metrics_.push_back(newMetric);
            registered_metric_types_[nname] = MMV_TYPE_DOUBLE;
            stop_mmv();
        }

        if (registered_metric_types_[nname] != MMV_TYPE_DOUBLE)
        {
            TLOG(TLVL_ERROR) << "PCP-MMV Metric: Metric instance has wrong type! Expected " << registered_metric_types_[nname]
                             << ", got double";
            return;
        }

        if ((mmvAddr_ == nullptr) && check_time_())
        {
            init_mmv();
        }

        if (mmvAddr_ != nullptr)
        {
            auto base = mmv_lookup_value_desc(mmvAddr_, nname.c_str(), nullptr);
            mmv_set_value(mmvAddr_, base, value);
        }
    }

    void sendMetric_(const std::string& name, const float& value, const std::string& unit, const std::chrono::system_clock::time_point&) override
    {
        auto nname = normalize_name_(name);
        if (registered_metric_types_.count(nname) == 0u)
        {
            TLOG(TLVL_INFO) << "Adding float metric named " << nname;
            mmv_metric_t newMetric;
            copy_string(newMetric.name, MMV_NAMEMAX, nname);
            newMetric.item = registered_metrics_.size();
            newMetric.type = MMV_TYPE_FLOAT;
            newMetric.semantics = MMV_SEM_INSTANT;
            newMetric.dimension = infer_units_(unit);
            newMetric.indom = 0;
            newMetric.helptext = nullptr;
            newMetric.shorttext = nullptr;

            registered_metrics_.push_back(newMetric);
            registered_metric_types_[nname] = MMV_TYPE_FLOAT;
            stop_mmv();
        }

        if (registered_metric_types_[nname] != MMV_TYPE_FLOAT)
        {
            TLOG(TLVL_ERROR) << "PCP-MMV Metric: Metric instance has wrong type! Expected " << registered_metric_types_[nname]
                             << ", got float";
            return;
        }

        if ((mmvAddr_ == nullptr) && check_time_())
        {
            init_mmv();
        }

        if (mmvAddr_ != nullptr)
        {
            auto base = mmv_lookup_value_desc(mmvAddr_, nname.c_str(), nullptr);
            mmv_set_value(mmvAddr_, base, value);
        }
    }

    void sendMetric_(const std::string& name, const uint64_t& value, const std::string& unit, const std::chrono::system_clock::time_point&) override
    {
        auto nname = normalize_name_(name);
        if (registered_metric_types_.count(nname) == 0u)
        {
            TLOG(TLVL_INFO) << "Adding unsigned metric named " << nname;
            mmv_metric_t newMetric;
            copy_string(newMetric.name, MMV_NAMEMAX, nname);
            newMetric.item = registered_metrics_.size();
            newMetric.type = MMV_TYPE_U64;
            newMetric.semantics = MMV_SEM_INSTANT;
            newMetric.dimension = infer_units_(unit);
            newMetric.indom = 0;
            newMetric.helptext = nullptr;
            newMetric.shorttext = nullptr;

            registered_metrics_.push_back(newMetric);
            registered_metric_types_[nname] = MMV_TYPE_U64;
            stop_mmv();
        }

        if (registered_metric_types_[nname] != MMV_TYPE_U64)
        {
            TLOG(TLVL_ERROR) << "PCP-MMV Metric: Metric instance has wrong type! Expected " << registered_metric_types_[nname]
                             << ", got unsigned int";
            return;
        }

        if ((mmvAddr_ == nullptr) && check_time_())
        {
            init_mmv();
        }

        if (mmvAddr_ != nullptr)
        {
            auto base = mmv_lookup_value_desc(mmvAddr_, nname.c_str(), nullptr);
            mmv_set_value(mmvAddr_, base, value);
        }
    }
};
}  // End namespace artdaq

DEFINE_ARTDAQ_METRIC(artdaq::PCPMMVMetric)

#endif  // End ifndef __PCPMMV_METRIC__