file_metric.cc

// FileMetric.h: File Metric Plugin
// Author: Eric Flumerfelt
// Last Modified: 11/06/2014
//
// An implementation of the MetricPlugin for Log Files

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

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

#include <sys/types.h>
#include <unistd.h>
#include <boost/filesystem.hpp>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <string>
namespace BFS = boost::filesystem;

namespace artdaq {
class FileMetric : public MetricPlugin
{
private:
    std::string outputFile_;
    bool file_name_is_absolute_path_;
    std::string relative_env_var_;
    bool uniquify_file_name_;
    std::ofstream outputStream_;
    std::ios_base::openmode mode_;
    std::string timeformat_;
    bool stopped_;

    std::ostream& getTime_(std::ostream& stream)
    {
        static std::mutex timeMutex;
        std::unique_lock<std::mutex> lk(timeMutex);
        using std::chrono::system_clock;
        std::time_t tt = system_clock::to_time_t(system_clock::now());

        struct std::tm* ptm = std::localtime(&tt);
        if (timeformat_.size())
        {
            return stream << std::put_time(ptm, timeformat_.c_str()) << ": ";
        }

        return stream;
    }

public:
    explicit FileMetric(fhicl::ParameterSet const& config, std::string const& app_name)
        : MetricPlugin(config, app_name)
        , outputFile_(pset.get<std::string>("fileName", "FileMetric.out"))
        , file_name_is_absolute_path_(pset.get<bool>("absolute_file_path", true))
        , relative_env_var_(pset.get<std::string>("relative_directory_env_var", "ARTDAQ_LOG_ROOT"))
        , uniquify_file_name_(pset.get<bool>("uniquify", false))
        , timeformat_(pset.get<std::string>("time_format", "%c"))
        , stopped_(true)
    {
        std::string modeString = pset.get<std::string>("fileMode", "append");

        mode_ = std::ofstream::out | std::ofstream::app;
        if (modeString == "Overwrite" || modeString == "Create" || modeString == "Write")
        {
            mode_ = std::ofstream::out | std::ofstream::trunc;
        }

        if (uniquify_file_name_)
        {
            std::string unique_id = std::to_string(getpid());
            if (outputFile_.find("%UID%") != std::string::npos)
            {
                outputFile_ = outputFile_.replace(outputFile_.find("%UID%"), 5, unique_id);
            }
            else
            {
                if (outputFile_.rfind(".") != std::string::npos)
                {
                    outputFile_ = outputFile_.insert(outputFile_.rfind("."), "_" + unique_id);
                }
                else
                {
                    outputFile_ = outputFile_.append("_" + unique_id);
                }
            }
        }
        openFile_();
        startMetrics();
    }

    virtual ~FileMetric()
    {
        stopMetrics();
        closeFile_();
    }

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

    void sendMetric_(const std::string& name, const std::string& value, const std::string& unit) override
    {
        if (!stopped_ && !inhibit_)
        {
            getTime_(outputStream_) << "FileMetric: " << name << ": " << value << " " << unit << "." << std::endl;
        }
    }

    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
    {
        stopped_ = false;
        getTime_(outputStream_) << "FileMetric plugin started." << std::endl;
    }

    void stopMetrics_() override
    {
        stopped_ = true;
        getTime_(outputStream_) << "FileMetric plugin has been stopped!" << std::endl;
    }

private:
    void openFile_()
    {
        if (!file_name_is_absolute_path_)
        {
            TLOG(TLVL_DEBUG) << "Reading relative directory evironment variable " << relative_env_var_;
            std::string logPathProblem = "";
            std::string logfileName = "";
            char* logRootString = getenv(relative_env_var_.c_str());

            std::string logfileDir = "";
            if (logRootString != nullptr)
            {
                if (!BFS::exists(logRootString))
                {
                    TLOG(TLVL_WARNING) << "Relative directory environment variable " << relative_env_var_ << " points to a non-existant directory! Using /tmp/!";
                    outputFile_ = "/tmp/" + outputFile_;
                    TLOG(TLVL_INFO) << "FileMetric Opening file " << outputFile_;
                    outputStream_.open(outputFile_, mode_);
                }
                else
                {
                    logfileDir = logRootString;
                    logfileDir.append("/metrics/");

                    while (outputFile_.find('/') != std::string::npos)
                    {
                        TLOG(TLVL_DEBUG) << "Extracting subdirectories from relative file path " << outputFile_ << " (logfileDir = " << logfileDir << ")";
                        logfileDir.append(outputFile_.substr(0, outputFile_.find('/') + 1));
                        outputFile_.erase(0, outputFile_.find('/') + 1);
                    }

                    // As long as the top-level directory exists, I don't think we
                    // really care if we have to create application directories...
                    TLOG(TLVL_DEBUG) << "Creating log file directory " << logfileDir;
                    if (!BFS::exists(logfileDir))
                        BFS::create_directories(logfileDir);

                    logfileName.append(logfileDir);
                    logfileName.append(outputFile_);

                    TLOG(TLVL_INFO) << "FileMetric Opening file " << logfileName;
                    outputStream_.open(logfileName, mode_);
                }
            }
            else
            {
                TLOG(TLVL_WARNING) << "Relative directory environment variable " << relative_env_var_ << " is null! Using /tmp/!";
                outputFile_ = "/tmp/" + outputFile_;
                TLOG(TLVL_INFO) << "FileMetric Opening file " << outputFile_;
                outputStream_.open(outputFile_, mode_);
            }
        }
        else
        {
            TLOG(TLVL_INFO) << "FileMetric Opening file " << outputFile_;
            outputStream_.open(outputFile_, mode_);
        }
        if (outputStream_.is_open())
        {
            getTime_(outputStream_) << "FileMetric plugin file opened." << std::endl;
        }
        else
        {
            TLOG(TLVL_ERROR) << "Error opening metric file " << outputFile_;
        }
    }

    void closeFile_()
    {
        getTime_(outputStream_) << "FileMetric closing file stream." << std::endl;
        outputStream_.close();
    }
};
}  // End namespace artdaq

DEFINE_ARTDAQ_METRIC(artdaq::FileMetric)