MemoryLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_MEMORYLOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_MEMORYLOGGER_HPP_INCLUDED
 
 
#include "ILogger.hpp"
#include "ILogReader.hpp"
#include "ILogSubscriber.hpp"
 
#include <map>
 
namespace logit {
 
    class MemoryLogger : public ILogger, public ILogReader, public ILogSubscriber {
    public:
        struct Config {
            std::size_t max_records = 1000;            
            std::size_t max_bytes   = 1024 * 1024;    
            int64_t     max_age_ms  = 24LL * 60 * 60 * 1000; 
 
            Config() {}
 
            Config(std::size_t max_records, std::size_t max_bytes, int64_t max_age_ms) :
                    max_records(max_records),
                    max_bytes(max_bytes),
                    max_age_ms(max_age_ms) {}
        };
 
        MemoryLogger() = default;
 
        explicit MemoryLogger(const Config& config) : m_config(config) {}
 
        MemoryLogger(std::size_t max_records, std::size_t max_bytes, int64_t max_age_ms) :
                m_config{max_records, max_bytes, max_age_ms} {}
 
        void log(const LogRecord& record, const std::string& message) override {
            if (!record.raw_mode &&
                static_cast<int>(record.log_level) < m_log_level.load(std::memory_order_relaxed)) {
                return;
            }
 
            BufferedLogEntry entry;
            entry.level = record.log_level;
            entry.timestamp_ms = record.timestamp_ms;
            entry.file = record.file;
            entry.line = record.line;
            entry.function = record.function;
            entry.message = message;
 
            LogRecordSnapshot written_snapshot;
            {
                std::lock_guard<std::mutex> lock(m_mutex);
                m_evict_expired_locked(record.timestamp_ms);
 
                // Capture an owning snapshot before moving the entry; callbacks
                // are dispatched only after the buffer update finishes.
                written_snapshot = to_snapshot(entry);
                m_total_bytes += m_entry_bytes(entry);
                m_entries.push_back(std::move(entry));
                m_last_log_ts.store(record.timestamp_ms, std::memory_order_relaxed);
                m_last_log_mono_ts.store(LOGIT_MONOTONIC_MS(), std::memory_order_relaxed);
 
                m_enforce_limits_locked(record.timestamp_ms);
            }
 
            notify_callbacks(written_snapshot);
        }
 
        std::string get_string_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return std::to_string(get_last_log_ts());
            case LoggerParam::TimeSinceLastLog:
                return std::to_string(get_time_since_last_log());
            default:
                break;
            }
            return std::string();
        }
 
        int64_t get_int_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return get_last_log_ts();
            case LoggerParam::TimeSinceLastLog:
                return get_time_since_last_log();
            default:
                break;
            }
            return 0;
        }
 
        double get_float_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return static_cast<double>(get_last_log_ts()) / 1000.0;
            case LoggerParam::TimeSinceLastLog:
                return static_cast<double>(get_time_since_last_log()) / 1000.0;
            default:
                break;
            }
            return 0.0;
        }
 
        void set_log_level(LogLevel level) override {
            m_log_level.store(static_cast<int>(level), std::memory_order_relaxed);
        }
 
        LogLevel get_log_level() const override {
            return static_cast<LogLevel>(m_log_level.load(std::memory_order_relaxed));
        }
 
        std::vector<std::string> get_buffered_strings() const override {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_evict_expired_locked(LOGIT_CURRENT_TIMESTAMP_MS());
 
            std::vector<std::string> snapshot;
            snapshot.reserve(m_entries.size());
            for (const auto& entry : m_entries) {
                snapshot.push_back(entry.message);
            }
            return snapshot;
        }
 
        std::vector<BufferedLogEntry> get_buffered_entries() const override {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_evict_expired_locked(LOGIT_CURRENT_TIMESTAMP_MS());
            return std::vector<BufferedLogEntry>(m_entries.begin(), m_entries.end());
        }
 
        void wait() override {}
 
        uint64_t add_log_callback(Callback callback) override {
            std::lock_guard<std::mutex> lock(m_callbacks_mutex);
            const uint64_t id = m_next_callback_id.fetch_add(1, std::memory_order_relaxed);
            m_callbacks.emplace(id, std::move(callback));
            return id;
        }
 
        bool remove_log_callback(uint64_t callback_id) override {
            std::lock_guard<std::mutex> lock(m_callbacks_mutex);
            return m_callbacks.erase(callback_id) > 0;
        }
 
        LogClearResult clear_logs(const LogClearOptions& options = LogClearOptions()) override {
            (void)options;
            std::lock_guard<std::mutex> lock(m_mutex);
            LogClearResult result;
            result.ok = true;
            result.status = LogClearStatus::Cleared;
            result.cleared_records = m_entries.size();
            result.message = "cleared";
            m_entries.clear();
            m_total_bytes = 0;
            m_last_log_ts.store(0, std::memory_order_relaxed);
            m_last_log_mono_ts.store(0, std::memory_order_relaxed);
            return result;
        }
 
        std::vector<LogRecordSnapshot> read_range(
                int64_t from_ms,
                int64_t to_ms,
                std::size_t limit = 0) const override {
#if __cplusplus >= 201703L
            auto result = read_range_result(from_ms, to_ms, limit);
            return result.value ? *result.value : std::vector<LogRecordSnapshot>();
#else
            std::vector<LogRecordSnapshot> out;
            if (to_ms <= from_ms) {
                return out;
            }
 
            std::lock_guard<std::mutex> lock(m_mutex);
            m_evict_expired_locked(LOGIT_CURRENT_TIMESTAMP_MS());
 
            for (const auto& entry : m_entries) {
                if (entry.timestamp_ms >= from_ms && entry.timestamp_ms < to_ms) {
                    out.push_back(to_snapshot(entry));
                    if (limit > 0 && out.size() >= limit) {
                        break;
                    }
                }
            }
            return out;
#endif
        }
 
#if __cplusplus >= 201703L
        LogReadResult<std::vector<LogRecordSnapshot>> read_range_result(
                int64_t from_ms,
                int64_t to_ms,
                std::size_t limit = 0) const override {
            LogReadResult<std::vector<LogRecordSnapshot>> result;
            result.value.emplace();
            if (to_ms <= from_ms) {
                return result;
            }
 
            std::lock_guard<std::mutex> lock(m_mutex);
            m_evict_expired_locked(LOGIT_CURRENT_TIMESTAMP_MS());
 
            for (const auto& entry : m_entries) {
                if (entry.timestamp_ms >= from_ms && entry.timestamp_ms < to_ms) {
                    result.value->push_back(to_snapshot(entry));
                    if (limit > 0 && result.value->size() >= limit) {
                        break;
                    }
                }
            }
            return result;
        }
#endif
 
        std::vector<LogRecordSnapshot> read_recent(
                std::size_t limit,
                int64_t period_ms = 0,
                LogReadOrder order = LogReadOrder::Ascending) const override {
#if __cplusplus >= 201703L
            auto result = read_recent_result(limit, period_ms, order);
            return result.value ? *result.value : std::vector<LogRecordSnapshot>();
#else
            std::vector<LogRecordSnapshot> out;
            std::lock_guard<std::mutex> lock(m_mutex);
            m_evict_expired_locked(LOGIT_CURRENT_TIMESTAMP_MS());
 
            const int64_t now_ms = LOGIT_CURRENT_TIMESTAMP_MS();
            const int64_t from_ms = (period_ms > 0) ? (now_ms - period_ms) : 0;
 
            for (auto it = m_entries.rbegin(); it != m_entries.rend(); ++it) {
                if (period_ms <= 0 || it->timestamp_ms >= from_ms) {
                    out.push_back(to_snapshot(*it));
                    if (limit > 0 && out.size() >= limit) {
                        break;
                    }
                }
            }
 
            if (order == LogReadOrder::Ascending) {
                std::reverse(out.begin(), out.end());
            }
            return out;
#endif
        }
 
#if __cplusplus >= 201703L
        LogReadResult<std::vector<LogRecordSnapshot>> read_recent_result(
                std::size_t limit,
                int64_t period_ms = 0,
                LogReadOrder order = LogReadOrder::Ascending) const override {
            LogReadResult<std::vector<LogRecordSnapshot>> result;
            result.value.emplace();
            std::lock_guard<std::mutex> lock(m_mutex);
            m_evict_expired_locked(LOGIT_CURRENT_TIMESTAMP_MS());
 
            const int64_t now_ms = LOGIT_CURRENT_TIMESTAMP_MS();
            const int64_t from_ms = (period_ms > 0) ? (now_ms - period_ms) : 0;
 
            for (auto it = m_entries.rbegin(); it != m_entries.rend(); ++it) {
                if (period_ms <= 0 || it->timestamp_ms >= from_ms) {
                    result.value->push_back(to_snapshot(*it));
                    if (limit > 0 && result.value->size() >= limit) {
                        break;
                    }
                }
            }
 
            if (order == LogReadOrder::Ascending) {
                std::reverse(result.value->begin(), result.value->end());
            }
            return result;
        }
#endif
 
    private:
        static LogRecordSnapshot to_snapshot(const BufferedLogEntry& e) {
            LogRecordSnapshot snapshot;
            snapshot.level = e.level;
            snapshot.timestamp_ms = e.timestamp_ms;
            snapshot.file = e.file;
            snapshot.line = e.line;
            snapshot.function = e.function;
            snapshot.message = e.message;
            return snapshot;
        }
 
        void notify_callbacks(const LogRecordSnapshot& snapshot) const {
            std::vector<Callback> callbacks_copy;
            {
                std::lock_guard<std::mutex> lock(m_callbacks_mutex);
                callbacks_copy.reserve(m_callbacks.size());
                for (const auto& kv : m_callbacks) {
                    callbacks_copy.push_back(kv.second);
                }
            }
            for (const auto& cb : callbacks_copy) {
                try {
                    cb(snapshot);
                } catch (...) {
                }
            }
        }
 
        // Count only the retained formatted payload, not the full object footprint.
        static std::size_t m_entry_bytes(const BufferedLogEntry& entry) {
            return entry.message.size();
        }
 
        void m_pop_front_locked() const {
            if (m_entries.empty()) {
                return;
            }
            m_total_bytes -= m_entry_bytes(m_entries.front());
            m_entries.pop_front();
        }
 
        void m_evict_expired_locked(int64_t now_ms) const {
            if (m_config.max_age_ms <= 0) {
                return;
            }
 
            const int64_t cutoff = now_ms - m_config.max_age_ms;
            while (!m_entries.empty() && m_entries.front().timestamp_ms < cutoff) {
                m_pop_front_locked();
            }
        }
 
        void m_enforce_limits_locked(int64_t now_ms) const {
            m_evict_expired_locked(now_ms);
 
            if (m_config.max_records > 0) {
                while (m_entries.size() > m_config.max_records) {
                    m_pop_front_locked();
                }
            }
 
            if (m_config.max_bytes > 0) {
                // If a single message exceeds the byte budget, eviction removes it too.
                while (m_total_bytes > m_config.max_bytes && !m_entries.empty()) {
                    m_pop_front_locked();
                }
            }
        }
 
        int64_t get_last_log_ts() const {
            return m_last_log_ts.load(std::memory_order_relaxed);
        }
 
        int64_t get_time_since_last_log() const {
            const int64_t last = m_last_log_mono_ts.load(std::memory_order_relaxed);
            if (last <= 0) {
                return 0;
            }
            const int64_t now = LOGIT_MONOTONIC_MS();
            return now > last ? (now - last) : 0;
        }
 
        Config m_config;
        mutable std::mutex m_mutex;
        mutable std::deque<BufferedLogEntry> m_entries;
        mutable std::size_t m_total_bytes = 0;
        std::atomic<int64_t> m_last_log_ts = ATOMIC_VAR_INIT(0);
        std::atomic<int64_t> m_last_log_mono_ts = ATOMIC_VAR_INIT(0);
        std::atomic<int> m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
        mutable std::mutex m_callbacks_mutex;
        std::map<uint64_t, Callback> m_callbacks;
        std::atomic<uint64_t> m_next_callback_id{1};
    };
 
} // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_MEMORYLOGGER_HPP_INCLUDED