log.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <pthread.h>
#include <filesystem>
#include <iostream>
#include <fstream>
#include <print>
#include <ranges>
#include <unistd.h>
 
#include "../std/concept.hpp"
#include "../std/string.hpp"

namespace ns_log
{
 
enum class Level : int
{
  CRITICAL,
  ERROR,
  WARN,
  INFO,
  DEBUG,
};
 
namespace
{
 
namespace fs = std::filesystem;
 
class Logger
{
  private:
    std::ofstream m_sink;
    Level m_level;
    pid_t m_pid;  
  public:
    Logger();
    Logger(Logger const&) = delete;
    Logger(Logger&&) = delete;
    Logger& operator=(Logger const&) = delete;
    Logger& operator=(Logger&&) = delete;
    void set_level(Level level);
    [[nodiscard]] Level get_level() const;
    [[nodiscard]] pid_t get_pid() const;
    void set_sink_file(fs::path const& path_file_sink);
    void set_as_fork();
    void flush();
    [[nodiscard]] std::ofstream& get_sink_file();
};

thread_local Logger logger;
 

static void fork_handler_parent()
{
  std::cout.flush();
  std::cerr.flush();
  ::fflush(nullptr);
}

void fork_handler_child()
{
  logger.set_sink_file("/dev/null");
}

inline Logger::Logger()
  : m_sink("/dev/null")
  , m_level(Level::CRITICAL)
  , m_pid(getpid())
{
  static thread_local bool registered = false;
  if (!registered)
  {
    pthread_atfork(fork_handler_parent, nullptr, fork_handler_child);
    registered = true;
  }
}

inline void Logger::set_sink_file(fs::path const& path_file_sink)
{
  // File to save logs into
  if ( const char* var = std::getenv("FIM_DEBUG"); var && std::string_view{var} == "1" )
  {
    if(path_file_sink != "/dev/null")
    {
      std::println("D::Logger file: {}", path_file_sink.string());
    }
  }
  // File output stream
  m_sink = std::ofstream(path_file_sink, std::ios::out | std::ios::trunc);
  // Check if file was opened successfully
  if(not m_sink.is_open())
  {
    std::println("E::Could not open file '{}'", path_file_sink.string());
  }
}

inline std::ofstream& Logger::get_sink_file()
{
  return m_sink;
}

inline void Logger::flush()
{
  if (auto& file = this->m_sink)
  {
    file.flush();
  }
}

inline void Logger::set_level(Level level)
{
  m_level = level;
}

inline Level Logger::get_level() const
{
  return m_level;
}

inline pid_t Logger::get_pid() const
{
  return m_pid;
}

inline void Logger::set_as_fork()
{
  m_pid = 0;
}
 
}

inline void set_level(Level level)
{
  logger.set_level(level);
}

inline Level get_level()
{
  return logger.get_level();
}

inline void set_sink_file(fs::path const& path_file_sink)
{
  logger.set_sink_file(path_file_sink);
}

inline void set_as_fork()
{
  logger.set_as_fork();
}

struct Location
{
  std::string_view m_str_file; 
  uint32_t m_line;             

  consteval Location(const char* str_file = __builtin_FILE() , uint32_t str_line = __builtin_LINE())
    : m_str_file(str_file)
    , m_line(str_line)
  {
    m_str_file = m_str_file.substr(m_str_file.find_last_of("/")+1);
  }

  constexpr auto get() const
  {
    return std::format("{}::{}", m_str_file, m_line);
  }
};

template<typename... Ts>
std::string vformat(std::string_view fmt, Ts&&... ts)
{
  return std::vformat(fmt, std::make_format_args(ts...));
}

class Writer
{
  private:
    Location m_loc;                           
    Level m_level;                            
    std::string m_prefix;                     
    std::reference_wrapper<std::ostream> ostream; 
 
  public:
    Writer(Location const& location, Level const& level, std::string prefix, std::ostream& ostream)
      : m_loc(location)
      , m_level(level)
      , m_prefix(prefix)
      , ostream(ostream)
    {}

    template<ns_concept::StringRepresentable T, typename... Args>
    requires ( ( ns_concept::StringRepresentable<Args> or ns_concept::Iterable<Args> ) and ... )
    void operator()(T&& format, Args&&... args)
    {
      // Get current PID to detect if this is a forked child process
      pid_t pid = getpid();
      // Create string
      std::string line;
      // Parent: show "PREFIX::file::line::", Child: show "PREFIX::child_pid::"
      line += (pid == logger.get_pid())? std::format("{}::{}::", m_prefix, m_loc.get())
        : std::format("{}::{}::", m_prefix, pid);
      // Append format and args
      line += vformat(ns_string::to_string(format), ns_string::to_string(args)...)
        // Remove new lines to avoid printing without a prefix
        | std::views::filter([](char c){ return c != '\n'; })
        // Make it into a string
        | std::ranges::to<std::string>();
      // Append a single newline
      line += '\n';
      // Push to file
      if(std::ofstream& sink = logger.get_sink_file(); sink.is_open())
      {
        sink << line;
      }
      // Push to stream
      if(logger.get_level() >= m_level)
      {
        ostream.get() << line;
      }
      logger.flush();
    }
};

class debug final : public Writer
{
  private:
    Location m_loc;
  public:
    debug(Location location = Location())
      : Writer(location, Level::DEBUG, "D", std::cout)
      , m_loc(location)
    {}
};

class info : public Writer
{
  private:
    Location m_loc;
  public:
    info(Location location = Location())
      : Writer(location, Level::INFO, "I", std::cout)
      , m_loc(location)
    {}
};

class warn : public Writer
{
  private:
    Location m_loc;
  public:
    warn(Location location = Location())
      : Writer(location, Level::WARN, "W", std::cerr)
      , m_loc(location)
    {}
};

class error : public Writer
{
  private:
    Location m_loc;
  public:
    error(Location location = Location())
      : Writer(location, Level::ERROR, "E", std::cerr)
      , m_loc(location)
    {}
};

class critical : public Writer
{
  private:
    Location m_loc;
  public:
    critical(Location location = Location())
      : Writer(location, Level::CRITICAL, "C", std::cerr)
      , m_loc(location)
    {}
};

#define logger(fmt, ...) ::ns_log::impl_log<fmt>(::ns_log::Location{})(__VA_ARGS__)

#define logger_loc(loc, fmt, ...) ::ns_log::impl_log<fmt>(loc)(__VA_ARGS__)

template<ns_string::static_string str>
constexpr decltype(auto) impl_log(Location loc)
{
  return [=]<typename... Ts>(Ts&&... ts)
  {
    constexpr std::string_view sv = str.data;
    if constexpr (sv.starts_with("I::"))
    {
      info{loc}(sv.substr(3), std::forward<Ts>(ts)...);
    }
    else if constexpr (sv.starts_with("W::"))
    {
      warn{loc}(sv.substr(3), std::forward<Ts>(ts)...);
    }
    else if constexpr (sv.starts_with("E::"))
    {
      error{loc}(sv.substr(3), std::forward<Ts>(ts)...);
    }
    else if constexpr (sv.starts_with("C::"))
    {
      critical{loc}(sv.substr(3), std::forward<Ts>(ts)...);
    }
    else if constexpr (sv.starts_with("Q::"))
    {
      // Discard
    }
    else
    {
      // It is necessary to repeat all conditions here due to how the compile-time language works
      static_assert(sv.starts_with("D::")
        or sv.starts_with("I::")
        or sv.starts_with("W::")
        or sv.starts_with("E::")
        or sv.starts_with("C::")
        or sv.starts_with("Q::")
      );
      ns_log::debug{loc}(sv.substr(3), std::forward<Ts>(ts)...);
    }
  };
}
 
} // namespace ns_log
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/