logging.h

Go to the documentation of this file.

 
#pragma once
 
// lib includes
#include <boost/log/common.hpp>
#include <boost/log/sinks.hpp>
 
using text_sink = boost::log::sinks::asynchronous_sink<boost::log::sinks::text_ostream_backend>;
 
extern boost::log::sources::severity_logger<int> verbose;  
extern boost::log::sources::severity_logger<int> debug;  
extern boost::log::sources::severity_logger<int> info;  
extern boost::log::sources::severity_logger<int> warning;  
extern boost::log::sources::severity_logger<int> error;  
extern boost::log::sources::severity_logger<int> fatal;  
#ifdef SUNSHINE_TESTS
extern boost::log::sources::severity_logger<int> tests;
#endif
 
#include "config.h"
#include "stat_trackers.h"
 
namespace logging {
  class deinit_t {
  public:
    ~deinit_t();
  };
 
  void deinit();
 
  void formatter(const boost::log::record_view &view, boost::log::formatting_ostream &os);
 
  [[nodiscard]] std::unique_ptr<deinit_t> init(int min_log_level, const std::string &log_file);
 
  void setup_av_logging(int min_log_level);
 
  void setup_libdisplaydevice_logging(int min_log_level);
 
  void log_flush();
 
  void print_help(const char *name);
 
  template<typename T>
  class min_max_avg_periodic_logger {
  public:
    min_max_avg_periodic_logger(boost::log::sources::severity_logger<int> &severity, std::string_view message, std::string_view units, std::chrono::seconds interval_in_seconds = std::chrono::seconds(20)):
        severity(severity),
        message(message),
        units(units),
        interval(interval_in_seconds),
        enabled(config::sunshine.min_log_level <= severity.default_severity()) {
    }
 
    void collect_and_log(const T &value) {
      if (enabled) {
        auto print_info = [&](const T &min_value, const T &max_value, double avg_value) {
          auto f = stat_trackers::two_digits_after_decimal();
          if constexpr (std::is_floating_point_v<T>) {
            BOOST_LOG(severity.get()) << message << " (min/max/avg): " << f % min_value << units << "/" << f % max_value << units << "/" << f % avg_value << units;
          } else {
            BOOST_LOG(severity.get()) << message << " (min/max/avg): " << min_value << units << "/" << max_value << units << "/" << f % avg_value << units;
          }
        };
        tracker.collect_and_callback_on_interval(value, print_info, interval);
      }
    }
 
    void collect_and_log(std::function<T()> func) {
      if (enabled) {
        collect_and_log(func());
      }
    }
 
    void reset() {
      if (enabled) {
        tracker.reset();
      }
    }
 
    bool is_enabled() const {
      return enabled;
    }
 
  private:
    std::reference_wrapper<boost::log::sources::severity_logger<int>> severity;
    std::string message;
    std::string units;
    std::chrono::seconds interval;
    bool enabled;
    stat_trackers::min_max_avg_tracker<T> tracker;
  };
 
  class time_delta_periodic_logger {
  public:
    time_delta_periodic_logger(boost::log::sources::severity_logger<int> &severity, std::string_view message, std::chrono::seconds interval_in_seconds = std::chrono::seconds(20)):
        logger(severity, message, "ms", interval_in_seconds) {
    }
 
    void first_point(const std::chrono::steady_clock::time_point &point) {
      if (logger.is_enabled()) {
        point1 = point;
      }
    }
 
    void first_point_now() {
      if (logger.is_enabled()) {
        first_point(std::chrono::steady_clock::now());
      }
    }
 
    void second_point_and_log(const std::chrono::steady_clock::time_point &point) {
      if (logger.is_enabled()) {
        logger.collect_and_log(std::chrono::duration<double, std::milli>(point - point1).count());
      }
    }
 
    void second_point_now_and_log() {
      if (logger.is_enabled()) {
        second_point_and_log(std::chrono::steady_clock::now());
      }
    }
 
    void reset() {
      if (logger.is_enabled()) {
        logger.reset();
      }
    }
 
    bool is_enabled() const {
      return logger.is_enabled();
    }
 
  private:
    std::chrono::steady_clock::time_point point1 = std::chrono::steady_clock::now();
    min_max_avg_periodic_logger<double> logger;
  };
 
  std::string bracket(const std::string &input);
 
  std::wstring bracket(const std::wstring &input);
 
}  // namespace logging