b2logging.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2logging.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012,2017
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef B2LOGGING_H_
#define B2LOGGING_H_
 
#include <algorithm>
#include <complex>
#include <fstream>
#include <ios>
#include <list>
#include <map>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>
 
#include "b2ppconfig.h"
#include "utils/b2csda.H"
#include "utils/b2exception.H"
#include "utils/b2object.H"
#include "utils/b2path.H"
#include "utils/b2time.H"
#include "utils/b2util.H"
 
#ifdef HAVE_LIB_TBB
#include "tbb/spin_mutex.h"
#define thread_local_storage __thread
#else
#define thread_local_storage
#endif
 
namespace b2000 { namespace logging {
 
class Level {
public:
    Level() : value(0) {}
 
    Level(const std::string& name) {
        std::vector<std::string>::iterator i = std::find(list_name.begin(), list_name.end(), name);
        if (i == list_name.end()) {
            KeyError() << "The logging level id " << name << " is not defined." << THROW;
        } else {
            value = i - list_name.begin();
        }
    }
 
    Level(const std::string& name_, int value_) : value(value_) {
        list_name.resize(value + 1);
        if (list_name[value].size() != 0) {
            if (list_name[value] == name_) { return; }
            KeyError() << "The logging level " << value
                       << " is already used by the logging level id " << list_name[value] << "."
                       << THROW;
        }
        list_name[value] = name_;
    }
 
    const std::string& get_name() const { return list_name[value]; }
 
    int get_value() const { return value; }
 
    bool operator<=(const Level l) const { return value <= l.value; }
 
    bool operator<(const Level l) const { return value < l.value; }
 
private:
    static std::vector<std::string> list_name;
    int value;
};
 
extern Level not_set;
 
extern Level critical;
 
extern Level error;
 
extern Level warning;
 
extern Level info;
 
extern Level data;
 
extern Level debug;
 
extern Level max_level;
 
class DBName : public std::string {
public:
    DBName() {}
    template <typename T1>
    DBName(const T1& t1) {
        std::ostringstream o;
        o << t1;
        *this += o.str();
    }
    template <typename T1, typename T2>
    DBName(const T1& t1, const T2& t2) {
        std::ostringstream o;
        o << t1 << "." << t2;
        *this += o.str();
    }
    template <typename T1, typename T2, typename T3>
    DBName(const T1& t1, const T2& t2, const T3& t3) {
        std::ostringstream o;
        o << t1 << "." << t2 << "." << t3;
        *this += o.str();
    }
    template <typename T1, typename T2, typename T3, typename T4>
    DBName(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
        std::ostringstream o;
        o << t1 << "." << t2 << "." << t3 << "." << t4;
        *this += o.str();
    }
    template <typename T1, typename T2, typename T3, typename T4, typename T5>
    DBName(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
        std::ostringstream o;
        o << t1 << "." << t2 << "." << t3 << "." << t4 << "." << t5;
        *this += o.str();
    }
    template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
    DBName(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
        std::ostringstream o;
        o << t1 << "." << t2 << "." << t3 << "." << t4 << "." << t5 << "." << t6;
        *this += o.str();
    }
};
 
class DBObject {
public:
    typedef std::list<DBObject>::const_iterator iterator;
 
    DBObject(
          size_t pos_, const DBName& name_, const std::string& subname_, size_t ndim_,
          const size_t dim_[][2], char type_, const void* value_)
        : pos(pos_),
          name(name_),
          subname(subname_),
          ndim(ndim_),
          type(type_),
          value(static_cast<const char*>(value_)) {
        std::copy((size_t*)dim_, (size_t*)(dim_ + ndim_), (size_t*)dim);
    }
    size_t pos;
    DBName name;
    std::string subname;
    size_t ndim;
    size_t dim[2][2];
    char type;
    const char* value;
};
 
class Formatter {
public:
    virtual ~Formatter() {}
 
    virtual std::string prefix(
          const std::string name, const Level level, const char* file, int line) const = 0;
 
    virtual void format(
          std::ostream& out, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end, bool with_dboject = true) const = 0;
};
 
class BasicFormatter : public Formatter {
public:
    BasicFormatter(const char* time_format_) : time_format(time_format_) {}
 
    std::string prefix(
          const std::string name, const Level level, const char* file, int line) const override {
        return level.get_name() + ":" + name + ":" + Time().time_formats(time_format) + ":";
    }
 
    void format(
          std::ostream& out, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end, bool with_dboject = true) const override;
 
protected:
    const char* time_format;
 
private:
    template <typename T>
    void write_dbobject(
          std::ostream& out, size_t ndim, const size_t dim[][2], const T* value) const {
        if (ndim == 1) {
            out << "( ";
            for (size_t i = 0; i != dim[0][0]; ++i, value += dim[0][1]) { out << *value << ", "; }
            out << ")" << std::endl;
        } else if (ndim == 2) {
            out << "( ";
            for (size_t i = 0; i != dim[0][0]; ++i, value += dim[0][1]) {
                out << "( ";
                const T* value1 = value;
                for (size_t j = 0; j != dim[1][0]; ++j, value1 += dim[1][1]) {
                    out << *value1 << ", ";
                }
                out << ")," << std::endl;
            }
            out << ")" << std::endl;
        } else {
            UnimplementedError() << THROW;
        }
    }
};
 
class AllFormatter : public BasicFormatter {
public:
    AllFormatter(const char* time_format_) : BasicFormatter(time_format_) {}
 
    std::string prefix(
          const std::string name, const Level level, const char* file, int line) const override {
        std::ostringstream s(BasicFormatter::prefix(name, level, file, line));
        s << file << ':' << line << ':';
        return s.str();
    }
};
 
class ColorFormatter : public BasicFormatter {
public:
    ColorFormatter(const char* time_format_) : BasicFormatter(time_format_) {}
 
    std::string prefix(
          const std::string name, const Level level, const char* file, int line) const override;
};
 
class Handler {
public:
    Handler(const Formatter* formatter_) : formatter(formatter_) {}
 
    virtual ~Handler() { delete formatter; }
 
    void set_formatter(const Formatter* formatter_) {
        delete formatter;
        formatter = formatter_;
    }
 
    void handle(
          const std::string name_, const Level level, const char* file, int line,
          const std::string& msg, DBObject::iterator begin, DBObject::iterator end) {
#ifdef HAVE_LIB_TBB
        tbb::spin_mutex::scoped_lock lock(mutex);
#endif
        if (formatter) {
            emit(formatter->prefix(name_, level, file, line), msg, begin, end);
        } else {
            emit("", msg, begin, end);
        }
    }
 
protected:
    virtual void emit(
          const std::string& prefix, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end) = 0;
 
    const Formatter* formatter;
 
private:
    std::string name;
#ifdef HAVE_LIB_TBB
    tbb::spin_mutex mutex;
#endif
};
 
class StreamHandler : public Handler {
public:
    StreamHandler(std::ostream& ostream_, const Formatter* formatter_)
        : Handler(formatter_), ostream(ostream_) {}
 
private:
    void emit(
          const std::string& prefix, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end) override {
        ostream << prefix << " ";
        formatter->format(ostream, msg, begin, end);
    }
    std::ostream& ostream;
};
 
class ExceptionHandler : public Handler {
public:
    ExceptionHandler() : Handler(nullptr) {}
 
private:
    void emit(
          const std::string& prefix, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end) override {
        LoggingError() << "This level of logging message is configured to raise an exception error."
                       << THROW;
    }
};
 
class FileHandler : public Handler {
public:
    FileHandler(const char* filename, std::ios_base::openmode mode, const Formatter* formatter_)
        : Handler(formatter_), ofstream(filename, mode) {}
 
    void open(
          const char* filename = "/dev/null", std::ios_base::openmode mode = std::ios_base::app) {
        ofstream.close();
        ofstream.open(filename, mode);
    }
 
protected:
    void emit(
          const std::string& prefix, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end) override {
        ofstream << prefix << " ";
        formatter->format(ofstream, msg, begin, end);
        Time t;
        if ((t - last_sync) > 5) {
            ofstream.flush();
            last_sync = t;
        }
    }
 
private:
    std::ofstream ofstream;
    Time last_sync;
};
 
class DBHandler : public Handler {
public:
    DBHandler(
          const char* db_name, const char* memcom_db_name, const char* db_log_file,
          std::ios_base::openmode mode, const Formatter* formatter_);
 
    ~DBHandler() override;
 
    void open(
          const char* db_name = nullptr, const char* memcom_db_name = "log.mc",
          const char* db_log_file = "log.txt", std::ios_base::openmode mode = std::ios_base::app);
 
protected:
    void emit(
          const std::string& prefix, const std::string& msg, DBObject::iterator begin,
          DBObject::iterator end) override;
 
private:
    static std::string get_name(const char* db_name, const char* suffix) {
        std::string name(db_name);
        name = path::abspath(name);
        if (!path::isdir(name)) {
            name += ".b2m";
            if (!path::isdir(name)) {
                Exception() << "Can not open the B2000 database \"" << name << "\"." << THROW;
            }
        }
        return path::join(name, suffix);
    }
    std::ofstream ofstream;
    int db_handler;
    double time_sync;
    Time last_sync;
};
 
class Logger {
public:
    Logger(const Logger& l)
        : name(l.name),
          parent(l.parent),
          list_children(l.list_children),
          list_handler(l.list_handler) {
#ifdef HAVE_LIB_TBB
        tbb::spin_mutex::scoped_lock lock(mutex);
#endif
        update();
    }
 
    struct Flush {
        Flush(const char* file_ = nullptr, int line_ = -1) : file(file_), line(line_) {}
        const char* file;
        int line;
    };
 
#define LOGFLUSH Logger::Flush(__FILE__, __LINE__)
 
    Logger& operator<<(const Level& level) {
        if (!thread_local_data) { thread_local_data = new thread_local_data_t(); }
        thread_local_data->current_level = level;
        return *this;
    }
 
    Logger& operator<<(const std::string& a) {
        if (thread_local_data->current_level <= real_max_logged_level) {
            thread_local_data->current_msg << a;
        }
        return *this;
    }
 
    template <typename T>
    Logger& operator<<(const T& n) {
        if (thread_local_data->current_level <= real_max_logged_level) {
            thread_local_data->current_msg << n;
        }
        return *this;
    }
 
    Logger& operator<<(const DBName& a) {
        if (thread_local_data->current_level <= real_max_logged_level) {
            thread_local_data->current_db_name = a;
        }
        return *this;
    }
 
    Logger& write(size_t size, const double* vector, size_t incr, const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'd', vector, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t size, const b2000::csda<double>* vector, size_t incr,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'z', vector, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t size, const std::complex<double>* vector, size_t incr,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'z', vector, subname);
        }
        return *this;
    }
 
    Logger& write(size_t size, const float* vector, size_t incr, const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'f', vector, subname);
        }
        return *this;
    }
 
    Logger& write(size_t size, const int* vector, size_t incr, const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'i', vector, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t size, const unsigned int* vector, size_t incr, const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'j', vector, subname);
        }
        return *this;
    }
 
    Logger& write(size_t size, const long* vector, size_t incr, const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'l', vector, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t size, const unsigned long* vector, size_t incr, const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[1][2] = {{size, incr}};
            write_untyped(1, dim, 'm', vector, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t dim1, size_t dim2, const double* matrix, size_t ldv,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[2][2] = {{dim1, 1}, {dim2, ldv}};
            write_untyped(2, dim, 'd', matrix, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t dim1, size_t dim2, const b2000::csda<double>* matrix, size_t ldv,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[2][2] = {{dim1, 1}, {dim2, ldv}};
            write_untyped(2, dim, 'z', matrix, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t dim1, size_t dim2, const std::complex<double>* matrix, size_t ldv,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[2][2] = {{dim1, 1}, {dim2, ldv}};
            write_untyped(2, dim, 'z', matrix, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t dim1, size_t dim2, const float* matrix, size_t ldv,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[2][2] = {{dim1, 1}, {dim2, ldv}};
            write_untyped(2, dim, 'f', matrix, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t dim1, size_t dim2, const int* matrix, size_t ldv,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[2][2] = {{dim1, 1}, {dim2, ldv}};
            write_untyped(2, dim, 'd', matrix, subname);
        }
        return *this;
    }
 
    Logger& write(
          size_t dim1, size_t dim2, const long* matrix, size_t ldv,
          const std::string& subname = "") {
        if (thread_local_data->current_level <= real_max_logged_level) {
            size_t dim[2][2] = {{dim1, 1}, {dim2, ldv}};
            write_untyped(2, dim, 'd', matrix, subname);
        }
        return *this;
    }
 
    Logger& operator<<(const Flush& flush) {
        for (real_list_handler_t::iterator i = real_list_handler_begin;
             i != real_list_handler_end && thread_local_data->current_level <= i->second; ++i) {
            if (thread_local_data->current_level <= i->second) {
                i->first->handle(
                      get_name(), thread_local_data->current_level, flush.file, flush.line,
                      thread_local_data->current_msg.str(), thread_local_data->list_dbo.begin(),
                      thread_local_data->list_dbo.end());
            }
        }
        thread_local_data->current_level = not_set;
        thread_local_data->current_msg.str("");
        thread_local_data->list_dbo.clear();
        return *this;
    }
 
    void log(const Level level, const std::string& msg, const char* file = nullptr, int line = -1) {
        if (!thread_local_data) { thread_local_data = new thread_local_data_t(); }
        for (real_list_handler_t::iterator i = real_list_handler_begin;
             i != real_list_handler_end && level <= i->second; ++i) {
            i->first->handle(
                  get_name(), level, file, line, msg, thread_local_data->list_dbo.begin(),
                  thread_local_data->list_dbo.end());
        }
    }
 
#define LOG(level, msg) log(level, msg, __FILE__, __LINE__)
 
    bool is_enabled_for(const Level level) const { return level <= real_max_logged_level; }
 
    const std::string get_name() const {
        if (parent) {
            if (parent != &root_logger) {
                return parent->get_name() + "." + name;
            } else {
                return name;
            }
        } else {
            return "all";
        }
    }
 
    void add_handler(Handler* handler, Level& level) {
        if (list_handler.count(handler)) {
            if (list_handler[handler] < level) { list_handler[handler] = level; }
        } else {
            list_handler[handler] = level;
        }
#ifdef HAVE_LIB_TBB
        tbb::spin_mutex::scoped_lock lock(mutex);
#endif
        update();
    }
 
    void remove_handler(Handler* handler) {
        list_handler.erase(handler);
#ifdef HAVE_LIB_TBB
        tbb::spin_mutex::scoped_lock lock(mutex);
#endif
        update();
    }
 
    Logger& get_logger(const std::string& logger_name) {
        int p = logger_name.find('.');
        list_children_t::iterator i = list_children.find(logger_name.substr(0, p));
        if (i == list_children.end()) {
            i = list_children
                      .insert(list_children_t::value_type(
                            logger_name.substr(0, p), Logger(logger_name.substr(0, p), this)))
                      .first;
        }
        if (p == -1) {
            return i->second;
        } else {
            return i->second.get_logger(logger_name.substr(p + 1));
        }
    }
 
    template <typename Function>
    void for_each(Function f) const {
        f(*this);
        for (list_children_t::const_iterator i = list_children.begin(); i != list_children.end();
             ++i) {
            i->second.for_each(f);
        }
    }
 
    void print_list(std::ostream& out, const std::string& prefix = "") const {
        for_each(PrintName(out, prefix));
    }
 
    static Logger root_logger;
 
private:
    void write_untyped(
          size_t ndim, size_t dim[][2], char element_type, const void* value,
          const std::string& subname = "") {
        thread_local_data->list_dbo.push_back(DBObject(
              thread_local_data->current_msg.str().size(), thread_local_data->current_db_name,
              subname, ndim, dim, element_type, value));
    }
 
    Logger(const std::string& name_, Logger* parent_) : name(name_), parent(parent_) {
#ifdef HAVE_LIB_TBB
        tbb::spin_mutex::scoped_lock lock(mutex);
#endif
        update();
    }
 
    struct Comp {
        bool operator()(
              const std::pair<Handler* const, Level>& a,
              const std::pair<Handler* const, Level>& b) const {
            return b.second < a.second;
        }
    };
 
    struct PrintName {
        PrintName(std::ostream& out_, const std::string& prefix_) : out(out_), prefix(prefix_) {}
        void operator()(const Logger& l) { out << prefix << l.get_name() << std::endl; }
        std::ostream& out;
        const std::string& prefix;
    };
 
    void update();
 
    std::string name;
    Logger* parent;
    typedef std::map<std::string, Logger> list_children_t;
    list_children_t list_children;
    typedef std::map<Handler*, Level> list_handler_t;
    list_handler_t list_handler;
 
    Level real_max_logged_level;
    typedef std::vector<std::pair<Handler*, Level> > real_list_handler_t;
    real_list_handler_t real_list_handler;
    real_list_handler_t::iterator real_list_handler_begin;
    real_list_handler_t::iterator real_list_handler_end;
 
    struct thread_local_data_t {
        std::ostringstream current_msg;
        Level current_level;
        DBName current_db_name;
        typedef std::list<DBObject> list_dbo_t;
        list_dbo_t list_dbo;
    };
    static thread_local_storage thread_local_data_t* thread_local_data;
 
#ifdef HAVE_LIB_TBB
    static tbb::spin_mutex mutex;
#endif
};
 
inline Logger& get_logger(const std::string& logger_name = "") {
    if (logger_name.empty()) { return Logger::root_logger; }
    return Logger::root_logger.get_logger(logger_name);
}
 
void parse_on_logging_option(
      const std::string& s, const std::string& db_name, const bool dry_run = false);
 
}}  // namespace b2000::logging
 
#endif // B2LOGGING_H_