Logger.hpp

Go to the documentation of this file.

// The Reactive C++ Toolbox.
// Copyright (C) 2013-2019 Swirly Cloud Limited
// Copyright (C) 2022 Reactive Markets Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef TOOLBOX_SYS_LOGGER_HPP
#define TOOLBOX_SYS_LOGGER_HPP
 
#include <toolbox/sys/Limits.hpp>
#include <toolbox/sys/Time.hpp>
#include <toolbox/util/Storage.hpp>
#include <toolbox/util/Concepts.hpp>
 
#include <boost/lockfree/queue.hpp>
#include <boost/lockfree/stack.hpp>
 
#include <thread>
 
namespace toolbox {
inline namespace sys {
 
class Logger;
 
enum class LogLevel : int {
    None,
    Crit,
    Error,
    Warn,
    Metric,
    Notice,
    Info,
    Debug
};
 
using LogMsgPtr = StoragePtr<MaxLogLine>;
inline constexpr std::size_t LogBufPoolCapacity = 64;
using LogBufPool = boost::lockfree::stack<LogMsgPtr, boost::lockfree::capacity<LogBufPoolCapacity>>;
 
TOOLBOX_API LogBufPool& log_buf_pool() noexcept;
 
TOOLBOX_API void set_log_warming_mode(bool enabled) noexcept;
 
TOOLBOX_API bool log_warming_mode_enabled() noexcept;
 
TOOLBOX_API Logger& null_logger() noexcept;
 
TOOLBOX_API Logger& std_logger() noexcept;
 
TOOLBOX_API Logger& sys_logger() noexcept;
 
TOOLBOX_API const char* log_label(LogLevel level) noexcept;
 
TOOLBOX_API LogLevel get_log_level() noexcept;
 
inline bool is_log_level(LogLevel level) noexcept
{
    return level <= get_log_level();
}
 
TOOLBOX_API LogLevel set_log_level(LogLevel level) noexcept;
 
TOOLBOX_API Logger& get_logger() noexcept;
 
TOOLBOX_API Logger& set_logger(Logger& logger) noexcept;
 
inline Logger& set_logger(std::nullptr_t) noexcept
{
    return set_logger(null_logger());
}
 
TOOLBOX_API void write_log(WallTime ts, LogLevel level, LogMsgPtr&& msg, std::size_t size) noexcept;
 
class TOOLBOX_API Logger {
  public:
    Logger() noexcept = default;
    virtual ~Logger();
 
    // Copy.
    Logger(const Logger&) noexcept = default;
    Logger& operator=(const Logger&) noexcept = default;
 
    // Move.
    Logger(Logger&&) noexcept = default;
    Logger& operator=(Logger&&) noexcept = default;
 
    void write_log(WallTime ts, LogLevel level, int tid, LogMsgPtr&& msg, std::size_t size,
                   bool warming_fake) noexcept
    {
        do_write_log(ts, level, tid, std::move(msg), size, warming_fake);
    }
 
  protected:
    virtual void do_write_log(WallTime ts, LogLevel level, int tid, LogMsgPtr&& msg,
                              std::size_t size, bool warming_fake) noexcept
        = 0;
};
 
class TOOLBOX_API AsyncLogger : public Logger {
    struct Task {
        WallTime ts;
        LogLevel level;
        int tid;
        char* msg;
        std::size_t size;
    };
 
  public:
    explicit AsyncLogger(Logger& logger);
    ~AsyncLogger() override;
 
    // Copy.
    AsyncLogger(const AsyncLogger&) = delete;
    AsyncLogger& operator=(const AsyncLogger&) = delete;
 
    // Move.
    AsyncLogger(AsyncLogger&&) = delete;
    AsyncLogger& operator=(AsyncLogger&&) = delete;
 
    bool run();
 
    void stop();
 
  private:
    void write_all_messages();
    void do_write_log(WallTime ts, LogLevel level, int tid, LogMsgPtr&& msg,
                      std::size_t size, bool warming_fake) noexcept override;
 
    Logger& logger_;
    boost::lockfree::queue<Task, boost::lockfree::fixed_sized<false>> tq_{512};
    std::atomic<bool> stop_{false};
 
    // warming mode variables
    std::atomic<int> fake_pushed_count_{0};
    std::atomic<WallTime> last_time_fake_pushed_{};
    static_assert(std::atomic<WallTime>::is_always_lock_free, "atomic not lock free");
};
 
class TOOLBOX_API ScopedLogLevel {
  public:
    explicit ScopedLogLevel(LogLevel level) noexcept
    : prev_{set_log_level(level)}
    {
    }
    ~ScopedLogLevel() { set_log_level(prev_); }
 
    // Copy.
    ScopedLogLevel(const ScopedLogLevel&) = delete;
    ScopedLogLevel& operator=(const ScopedLogLevel&) = delete;
 
    // Move.
    ScopedLogLevel(ScopedLogLevel&&) = delete;
    ScopedLogLevel& operator=(ScopedLogLevel&&) = delete;
 
  private:
    const LogLevel prev_;
};
 
class TOOLBOX_API ScopedLogger {
  public:
    explicit ScopedLogger(Logger& logger) noexcept
    : prev_{set_logger(logger)}
    {
    }
    ~ScopedLogger() { set_logger(prev_); }
 
    // Copy.
    ScopedLogger(const ScopedLogger&) = delete;
    ScopedLogger& operator=(const ScopedLogger&) = delete;
 
    // Move.
    ScopedLogger(ScopedLogger&&) = delete;
    ScopedLogger& operator=(ScopedLogger&&) = delete;
 
  private:
    Logger& prev_;
};
 
template <typename StreamT>
    requires Streamable<StreamT>
StreamT& operator<<(StreamT& os, LogLevel level)
{
    os << log_label(level);
    return os;
}
 
} // namespace sys
} // namespace toolbox
 
#endif // TOOLBOX_SYS_LOGGER_HPP