Logging.h

Go to the documentation of this file.

 
#ifndef __ROGUE_LOGGING_H__
#define __ROGUE_LOGGING_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <atomic>
#include <exception>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
namespace rogue {
 
class LogFilter {
  public:
    std::string name_;
    uint32_t level_;
 
    LogFilter(std::string name, uint32_t level) {
        name_  = name;
        level_ = level;
    }
};
 
class Logging {
    // Global logging level
    static uint32_t gblLevel_;
 
    // Logging-level lock
    static std::mutex levelMtx_;
 
    // Name/level filters
    static std::vector<rogue::LogFilter*> filters_;
 
    // Active logger instances
    static std::vector<rogue::Logging*> loggers_;
 
    // Optional forwarding of Rogue C++ logs into Python logging
    static bool forwardPython_;
 
    // Optional emission of Rogue C++ logs to stdout
    static bool emitStdout_;
 
    void intLog(uint32_t level, const char* format, va_list args);
 
    void updateLevelLocked();
 
    // Local logger level
    std::atomic<uint32_t> level_;
 
    // Logger name
    std::string name_;
 
  public:
    static const uint32_t Critical = 50;
    static const uint32_t Error    = 40;
    static const uint32_t Thread   = 35;
    static const uint32_t Warning  = 30;
    static const uint32_t Info     = 20;
    static const uint32_t Debug    = 10;
 
    static std::shared_ptr<rogue::Logging> create(const std::string& name, bool quiet = false);
 
    explicit Logging(const std::string& name, bool quiet = false);
    ~Logging();
 
    static void setLevel(uint32_t level);
 
    static void setFilter(const std::string& filter, uint32_t level);
 
    static void setForwardPython(bool enable);
 
    static bool forwardPython();
 
    static void setEmitStdout(bool enable);
 
    static bool emitStdout();
 
    static std::string normalizeName(const std::string& name);
 
    void log(uint32_t level, const char* fmt, ...);
 
    void critical(const char* fmt, ...);
    void error(const char* fmt, ...);
    void warning(const char* fmt, ...);
    void info(const char* fmt, ...);
    void debug(const char* fmt, ...);
 
    void logThreadId();
 
    const std::string& name() const;
 
    static void setup_python();
};
 
typedef std::shared_ptr<rogue::Logging> LoggingPtr;
}  // namespace rogue
 
#endif