log.h

Go to the documentation of this file.

// Copyright (c) 2018, Smart Projects Holdings Ltd
// All rights reserved.
// See LICENSE file for license details.

#ifndef _UGCS_VSM_LOG_H_
#define _UGCS_VSM_LOG_H_

#include <ugcs/vsm/exception.h>

#include <stdlib.h>

#include <cstdio>
#include <cstdarg>
#include <string>
#include <memory>
#include <mutex>
#include <cinttypes>

namespace ugcs {
namespace vsm {

class Log {
public:
    VSM_DEFINE_EXCEPTION(Exception);

    enum class Level {
        DEBUGGING,
        INFO,
        WARNING,
        ERROR,

        MAX = ERROR
    };

    class Platform_logger {
    public:
        static std::unique_ptr<Platform_logger>
        Create(Log &log);

        Platform_logger(Log &log):
            log(log)
        {}

        virtual
        ~Platform_logger()
        {}

        virtual void
        Write_message(Level level, const char *msg, std::va_list args)
            __FORMAT(printf, 3, 0) = 0;

    protected:
        Log &log;
    };

    Log();

    ~Log();

    static const char *
    Get_level_str(Level level);

    static std::string
    Get_basename(const char *path);

    static std::string
    Get_system_error();

    static void
    Write_message(Level level, const char *msg, ...) __FORMAT(printf, 2, 3);

    static void
    Write_message_v(Level level, const char *msg, std::va_list args) __FORMAT(printf, 2, 0);

    void
    Write_message_inst(Level level, const char *msg, ...) __FORMAT(printf, 3, 4);

    void
    Write_message_v_inst(Level level, const char *msg, std::va_list args) __FORMAT(printf, 3, 0);

    static void
    Set_level(Level level)
    {
        /* No need for separate lock because concurrent modification in any case
         * will give unpredictable result.
         */
        Get_instance()->cur_level = level;
    }

    static void
    Set_level(const std::string &level);

    static void
    Set_custom_log(const std::string &log_file)
    {
        Get_instance()->Set_custom_log_inst(log_file);
    }

    void
    Set_custom_log_inst(const std::string &log_file);

    static void
    Set_max_custom_log_size(const std::string& size_str);

    static void
    Set_max_custom_log_count(size_t count);

    void
    Set_max_custom_log_size_inst(ssize_t size);

    void
    Set_max_custom_log_count_inst(size_t count);

private:
    friend class Platform_logger;

    constexpr static ssize_t MIN_CUSTOM_LOG_FILE_SIZE = 16384;

    constexpr static ssize_t DEFAULT_MAX_CUSTOM_LOG_FILE_SIZE = 100 * 1024 * 1024;

    constexpr static const char* const LOG_FILE_ROTATOR_SUFFIX_FORMAT = "_%Y%m%d-%H%M%S";

    constexpr static const char* const LOG_FILE_ROTATOR_FIND_PATTERN  = "_\?\?\?\?\?\?\?\?-\?\?\?\?\?\?*";

    Level cur_level =
#   ifdef DEBUG
        Level::DEBUGGING;
#   else /* DEBUG */
        Level::INFO;
#   endif /* DEBUG */

    std::mutex mutex;
    static volatile Log *log;
    bool use_console = true;
    std::unique_ptr<Platform_logger> plat_logger;
    std::string custom_log_file_name;
    FILE* custom_log_file = nullptr;
    ssize_t max_custom_log = DEFAULT_MAX_CUSTOM_LOG_FILE_SIZE;
    ssize_t custom_log_size;

    size_t custom_log_count = 1;

    static Log *
    Get_instance();

    bool
    Reopen_custom_log_file(const std::string &log_file);

    void
    Write_custom_message(int thread_id, Log::Level level, const char *msg,
            std::va_list args) __FORMAT(printf, 4, 0);

    void
    Write_console_message_inst(int thread_id, Level level, const char *msg, ...) __FORMAT(printf, 4, 5);

    void
    Write_console_message_v_inst(int thread_id, Level level, const char *msg,
            std::va_list args) __FORMAT(printf, 4, 0);

    static int
    Vprintf_utf8(const char *format, std::va_list args) __FORMAT(printf, 1, 0);

    static int
    Printf_utf8(const char *format, ...) __FORMAT(printf, 1, 2);

    bool
    Is_cleanup_needed();

    void
    Do_cleanup(int thread_id);

    void
    Remove_old_log_files();
};

#define _LOG_WRITE_MSG(level, msg, ...) \
    ::ugcs::vsm::Log::Write_message(level, "[%s:%d] " msg, \
                            ::ugcs::vsm::Log::Get_basename(__FILE__).c_str(), \
                            __LINE__, ## __VA_ARGS__)

#define LOG_DEBUG(msg, ...) \
    _LOG_WRITE_MSG(::ugcs::vsm::Log::Level::DEBUGGING, msg, ## __VA_ARGS__)

#define LOG_DBG     LOG_DEBUG

#define LOG         LOG_DEBUG

#define LOG_INFO(msg, ...) \
    _LOG_WRITE_MSG(::ugcs::vsm::Log::Level::INFO, msg, ## __VA_ARGS__)

#define LOG_WARNING(msg, ...) \
    _LOG_WRITE_MSG(::ugcs::vsm::Log::Level::WARNING, msg, ## __VA_ARGS__)

#define LOG_WARN    LOG_WARNING

#define LOG_ERROR(msg, ...) \
    _LOG_WRITE_MSG(::ugcs::vsm::Log::Level::ERROR, msg, ## __VA_ARGS__)

#define LOG_ERR     LOG_ERROR

} /* namespace vsm */
} /* namespace ugcs */

#endif /* _UGCS_VSM_LOG_H_ */