ZMQLogger.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2019 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Nils Braun                                               *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <variant>
#include <chrono>
#include <vector>
#include <map>
#include <unordered_map>
#include <numeric>
#include <string>
 
namespace Belle2 {
  class ZMQLogger {
  public:
    virtual std::string getMonitoringJSON() const;
 
    template<class AClass>
    void log(const std::string& key, const AClass& value);
    void increment(const std::string& key);
    void decrement(const std::string& key);
    template<size_t MAX_SIZE = 100>
    void average(const std::string& key, double value);
    template<size_t AVERAGE_SIZE = 2000>
    void timeit(const std::string& key);
    void logTime(const std::string& key);
 
  private:
    std::map<std::string, std::variant<long, double, std::string>> m_monitoring;
    std::unordered_map<std::string, std::tuple<std::vector<double>, size_t>> m_averages;
    std::unordered_map<std::string, std::tuple<unsigned long, std::chrono::system_clock::time_point>> m_timeCounters;
 
    struct toJSON {
      std::string operator()(long value);
      std::string operator()(double value);
      std::string operator()(const std::string& value);
    };
 
    struct Incrementor {
      void operator()(long& value);
      void operator()(double& value);
      void operator()(std::string&);
    };
 
    struct Decrementor {
      void operator()(long& value);
      void operator()(double& value);
      void operator()(std::string&);
    };
  };
 
  template<class AClass>
  void ZMQLogger::log(const std::string& key, const AClass& value)
  {
    m_monitoring[key] = value;
  }
 
  template<size_t MAX_SIZE>
  void ZMQLogger::average(const std::string& key, double value)
  {
    auto& [averages, index] = m_averages[key];
 
    if (averages.size() == MAX_SIZE) {
      averages[index] = value;
      index = (index + 1) % MAX_SIZE;
    } else {
      averages.push_back(value);
    }
 
    log(key, std::accumulate(averages.begin(), averages.end(), 0.0) / averages.size());
  }
 
  template<size_t AVERAGE_SIZE>
  void ZMQLogger::timeit(const std::string& key)
  {
    auto& [calls, timestamp] = m_timeCounters[key];
    if (calls % AVERAGE_SIZE == 0) {
      auto current = std::chrono::high_resolution_clock::now();
      double elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(
                         current - timestamp).count();
 
      log(key, AVERAGE_SIZE / elapsed);
 
      timestamp = current;
      calls = 0;
 
      auto displayTime = std::chrono::system_clock::to_time_t(current);
      log(key + "_last_measurement", std::ctime(&displayTime));
    }
    calls++;
  }
}