logging.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <cstddef>
#include <filesystem>
#include <format>
#include <string>
#include <system_error>
 
// 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 {
  inline constexpr std::size_t retained_log_file_count {5};

  inline std::error_code rotate_log_file(const std::filesystem::path &log_file) noexcept {
    const auto rotated_log_path = [&log_file](std::size_t generation) {
      auto rotated_path = log_file;
      rotated_path += std::format(".{}", generation);
      return rotated_path;
    };
 
    try {
      std::filesystem::remove(rotated_log_path(retained_log_file_count));
 
      for (auto generation = retained_log_file_count; generation > 1; --generation) {
        const auto previous_path = rotated_log_path(generation - 1);
        if (std::filesystem::exists(previous_path)) {
          std::filesystem::rename(previous_path, rotated_log_path(generation));
        }
      }
 
      if (std::filesystem::exists(log_file)) {
        std::filesystem::rename(log_file, rotated_log_path(1));
      }
 
      return {};
    } catch (const std::filesystem::filesystem_error &filesystem_error) {
      return filesystem_error.code();
    }
  }

  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