ealogger.h

Go to the documentation of this file.

//   ealogger is a simple, asynchronous and powerful logger library for c++
//   Copyright 2013 - 2016 Christian Rapp
//
//   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 EALOGGER_H
#define EALOGGER_H

#include <string>
/*
 * Mutual exclusion for threadsafe logger
 */
#include <csignal>
#include <iostream>
#include <mutex>
#include <stdexcept>
/*
 * Background logger thread
 */
#include <map>
#include <thread>
#include <vector>

#include <ealogger/global.h>
#include <ealogger/logmessage.h>
#include <ealogger/logqueue.h>
#include <ealogger/sink_console.h>
#include <ealogger/sink_file.h>
#include <ealogger/sink_syslog.h>
#include "config.h"

namespace ealogger
{
// Define macros for all log levels and call public member write_log()
#define eal_debug(msg)                                                  \
    write_log(msg, ealogger::constants::LOG_LEVEL::EAL_DEBUG, __FILE__, \
              __LINE__, __func__)

#define eal_info(msg)                                                  \
    write_log(msg, ealogger::constants::LOG_LEVEL::EAL_INFO, __FILE__, \
              __LINE__, __func__)

#define eal_warn(msg)                                                     \
    write_log(msg, ealogger::constants::LOG_LEVEL::EAL_WARNING, __FILE__, \
              __LINE__, __func__)

#define eal_error(msg)                                                  \
    write_log(msg, ealogger::constants::LOG_LEVEL::EAL_ERROR, __FILE__, \
              __LINE__, __func__)

#define eal_fatal(msg)                                                  \
    write_log(msg, ealogger::constants::LOG_LEVEL::EAL_FATAL, __FILE__, \
              __LINE__, __func__)

#define eal_stack()                                                    \
    write_log("", ealogger::constants::LOG_LEVEL::EAL_STACK, __FILE__, \
              __LINE__, __func__)

class Logger
{
public:
    Logger(bool async = true);
    ~Logger();

    void write_log(std::string msg, ealogger::constants::LOG_LEVEL lvl,
                   std::string file, int lnumber, std::string func);


     // overload void write_log(std::string, ealogger::constants::LOG_LEVEL, std::string, int, std::string)

    void write_log(std::string msg, ealogger::constants::LOG_LEVEL lvl);

    void init_syslog_sink(bool enabled = true,
                          ealogger::constants::LOG_LEVEL min_lvl =
                              ealogger::constants::LOG_LEVEL::EAL_DEBUG,
                          std::string msg_template = "%s: %m",
                          std::string datetime_pattern = "%F %T");
    void init_console_sink(bool enabled = true,
                           ealogger::constants::LOG_LEVEL min_lvl =
                               ealogger::constants::LOG_LEVEL::EAL_DEBUG,
                           std::string msg_template = "%d %s: %m",
                           std::string datetime_pattern = "%F %T");

    void init_file_sink(bool enabled = true,
                        ealogger::constants::LOG_LEVEL min_lvl =
                            ealogger::constants::LOG_LEVEL::EAL_DEBUG,
                        std::string msg_template = "%d %s [%f:%l] %m",
                        std::string datetime_pattern = "%F %T",
                        std::string logfile = "ealogger_logfile.log",
                        bool flush_buffer = false);
    // void init_file_sink_rotating(bool enabled,
    // ealogger::constants::LOG_LEVEL min_lvl,
    // std::string msg_template,
    // std::string datetime_pattern,
    // std::string logfile);
    void discard_sink(ealogger::constants::LOGGER_SINK sink);

    bool is_initialized(ealogger::constants::LOGGER_SINK sink);

    void set_msg_template(ealogger::constants::LOGGER_SINK sink,
                          std::string msg_template);
    void set_datetime_pattern(ealogger::constants::LOGGER_SINK sink,
                              std::string datetime_pattern);
    void set_enabled(ealogger::constants::LOGGER_SINK sink, bool enabled);
    void set_min_lvl(ealogger::constants::LOGGER_SINK sink,
                     ealogger::constants::LOG_LEVEL min_level);

    bool queue_empty();

private:
    std::mutex mtx_logger_stop;

    static bool signal_SIGUSR1;

    bool async;

    LogQueue log_msg_queue;
    std::thread logger_thread;
    bool logger_thread_stop;

    std::map<ealogger::constants::LOGGER_SINK, std::shared_ptr<Sink>>
        logger_sink_map;
    std::map<ealogger::constants::LOGGER_SINK, std::unique_ptr<std::mutex>>
        logger_mutex_map;

    static void logrotate(int signo);

    void thread_entry_point();

    void internal_log_routine(std::shared_ptr<LogMessage> m);

    /*
     * So far controlling the background logger thread is only possible for the
     * logger object itself.
     */
    bool get_logger_thread_stop();
    void set_logger_thread_stop(bool stop);
};
}

#endif  // EALOGGER_H