Change logging to easylogging++

This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.

To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:

This one is (mostly) silent, only outputting fatal errors:

MONERO_LOGS=*:FATAL

This one is very verbose:

MONERO_LOGS=*:TRACE

This one is totally silent (logwise):

MONERO_LOGS=""

This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):

MONERO_LOGS=*:WARNING,verify:FATAL

Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE

Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:

MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE

Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.

Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.

The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.

1 files changed, 96 insertions, 1339 deletions

diff --git a/contrib/epee/include/misc_log_ex.h b/contrib/epee/include/misc_log_ex.h
index 82760dfff..f04282438 100644
--- a/contrib/epee/include/misc_log_ex.h
+++ b/contrib/epee/include/misc_log_ex.h
@@ -28,9 +28,13 @@
 #ifndef _MISC_LOG_EX_H_
 #define _MISC_LOG_EX_H_
 
-//#include <windows.h>
-#include <atomic>
-#include <string>
+#include "static_initializer.h"
+#include "string_tools.h"
+#include "time_helper.h"
+#include "misc_os_dependent.h"
+
+#include "syncobj.h"
+
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -38,42 +42,79 @@
 #include <algorithm>
 #include <list>
 #include <map>
+#include <string>
 #include <time.h>
 #include <boost/cstdint.hpp>
 #include <boost/thread.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string.hpp>
 
-#if defined(WIN32)
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
-
-#include "static_initializer.h"
-#include "string_tools.h"
-#include "time_helper.h"
-#include "misc_os_dependent.h"
-
-#include "syncobj.h"
-
-
-#define LOG_LEVEL_SILENT     -1
-#define LOG_LEVEL_0     0
-#define LOG_LEVEL_1     1
-#define LOG_LEVEL_2     2
-#define LOG_LEVEL_3     3
-#define LOG_LEVEL_4     4
-#define LOG_LEVEL_MIN   LOG_LEVEL_SILENT
-#define LOG_LEVEL_MAX   LOG_LEVEL_4
-
-
-#define   LOGGER_NULL       0
-#define   LOGGER_FILE       1
-#define   LOGGER_DEBUGGER   2
-#define   LOGGER_CONSOLE    3
-#define   LOGGER_DUMP       4
-
+#define ELPP_THREAD_SAFE
+#define ELPP_DEFAULT_LOG_FILE ""
+#define ELPP_STACKTRACE 0
+#define ELPP_DISABLE_DEFAULT_CRASH_HANDLING
+#define ELPP_DISABLE_CHECK_MACROS
+#include "easylogging++.h"
+
+#define MONERO_DEFAULT_LOG_CATEGORY "default"
+
+#define MCFATAL(cat,x) CLOG(FATAL,cat) << x
+#define MCERROR(cat,x) CLOG(ERROR,cat) << x
+#define MCWARNING(cat,x) CLOG(WARNING,cat) << x
+#define MCINFO(cat,x) CLOG(INFO,cat) << x
+#define MCDEBUG(cat,x) CLOG(DEBUG,cat) << x
+#define MCTRACE(cat,x) CLOG(TRACE,cat) << x
+#define MCLOG(level,cat,x) ELPP_WRITE_LOG(el::base::Writer, level, el::base::DispatchAction::NormalLog, cat) << x
+
+#define MCLOG_COLOR(level,cat,color,x) MCLOG(level,cat,"\033[1;" color "m" << x << "\033[0m")
+#define MCLOG_RED(level,cat,x) MCLOG_COLOR(level,cat,"31",x)
+#define MCLOG_GREEN(level,cat,x) MCLOG_COLOR(level,cat,"32",x)
+#define MCLOG_YELLOW(level,cat,x) MCLOG_COLOR(level,cat,"33",x)
+#define MCLOG_BLUE(level,cat,x) MCLOG_COLOR(level,cat,"34",x)
+#define MCLOG_MAGENTA(level,cat,x) MCLOG_COLOR(level,cat,"35",x)
+#define MCLOG_CYAN(level,cat,x) MCLOG_COLOR(level,cat,"36",x)
+
+#define MLOG_RED(level,x) MCLOG_RED(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MLOG_GREEN(level,x) MCLOG_GREEN(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MLOG_YELLOW(level,x) MCLOG_YELLOW(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MLOG_BLUE(level,x) MCLOG_BLUE(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MLOG_MAGENTA(level,x) MCLOG_MAGENTA(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MLOG_CYAN(level,x) MCLOG_CYAN(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+
+#define MFATAL(x) MCFATAL(MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MTRACE(x) MCTRACE(MONERO_DEFAULT_LOG_CATEGORY,x)
+#define MLOG(level,x) MCLOG(level,MONERO_DEFAULT_LOG_CATEGORY,x)
+
+#define MGINFO(x) MCINFO("global",x)
+#define MGINFO_RED(x) MCLOG_RED(el::Level::Info, "global",x)
+#define MGINFO_GREEN(x) MCLOG_GREEN(el::Level::Info, "global",x)
+#define MGINFO_YELLOW(x) MCLOG_YELLOW(el::Level::Info, "global",x)
+#define MGINFO_BLUE(x) MCLOG_BLUE(el::Level::Info, "global",x)
+#define MGINFO_MAGENTA(x) MCLOG_MAGENTA(el::Level::Info, "global",x)
+#define MGINFO_CYAN(x) MCLOG_CYAN(el::Level::Info, "global",x)
+
+#define LOG_ERROR(x) MERROR(x)
+#define LOG_PRINT_L0(x) MWARNING(x)
+#define LOG_PRINT_L1(x) MINFO(x)
+#define LOG_PRINT_L2(x) MDEBUG(x)
+#define LOG_PRINT_L3(x) MTRACE(x)
+#define LOG_PRINT_L4(x) MTRACE(x)
+
+#define _dbg3(x) MTRACE(x)
+#define _dbg2(x) MDEBUG(x)
+#define _dbg1(x) MDEBUG(x)
+#define _info(x) MINFO(x)
+#define _note(x) MINFO(x)
+#define _fact(x) MINFO(x)
+#define _mark(x) MINFO(x)
+#define _warn(x) MWARNING(x)
+#define _erro(x) MERROR(x)
+
+#define MLOG_SET_THREAD_NAME(x) el::Loggers::setThreadName(x)
 
 #ifndef LOCAL_ASSERT
 #include <assert.h>
@@ -85,6 +126,12 @@
 
 #endif
 
+std::string mlog_get_default_log_path(const char *default_filename);
+void mlog_configure(const std::string &filename_base, bool console);
+void mlog_set_categories(const char *categories);
+void mlog_set_log_level(int level);
+void mlog_set_log(const char *log);
+
 namespace epee
 {
 namespace debug
@@ -97,1312 +144,8 @@ namespace debug
     return e;
   }
 }
-namespace log_space
-{
-  class  logger;
-  class  log_message;
-  class  log_singletone;
-
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  enum console_colors
-  {
-    console_color_default,
-    console_color_white,
-    console_color_red,
-    console_color_green,
-    console_color_blue,
-    console_color_cyan,
-    console_color_magenta,
-    console_color_yellow
-  };
-
-
-  struct ibase_log_stream
-  {
-    ibase_log_stream(){}
-    virtual ~ibase_log_stream(){}
-    virtual bool out_buffer( const char* buffer, int buffer_len , int log_level, int color, const char* plog_name = NULL)=0;
-    virtual int get_type(){return 0;}
-
-    virtual bool set_max_logfile_size(uint64_t max_size){return true;};
-    virtual bool set_log_rotate_cmd(const std::string& cmd){return true;};
-  };
-
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  /*struct ibase_log_value
-  {
-  public:
-    virtual void debug_out( std::stringstream*  p_stream)const = 0;
-  };*/
-
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  /*class log_message: public std::stringstream
-  {
-  public:
-    log_message(const  log_message& lm): std::stringstream(), std::stringstream::basic_ios()
-    {}
-    log_message(){}
-
-    template<class T>
-    log_message& operator<< (T t)
-    {
-      std::stringstream* pstrstr = this;
-      (*pstrstr) << t;
-
-      return *this;
-    }
-  };
-  inline
-  log_space::log_message& operator<<(log_space::log_message& sstream, const ibase_log_value& log_val)
-  {
-    log_val.debug_out(&sstream);
-    return sstream;
-  }
-  */
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  struct delete_ptr
-  {
-    template <class P>
-      void operator() (P p)
-    {
-      delete p.first;
-    }
-  };
-
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  //------------------------------------------------------------------------
-#define max_dbg_str_len 80
-#ifdef _MSC_VER
-  class debug_output_stream: public ibase_log_stream
-  {
-    virtual bool out_buffer( const char* buffer, int buffer_len , int log_level, int color, const char* plog_name = NULL)
-    {
-      for ( int i = 0; i <  buffer_len; i = i + max_dbg_str_len )
-      {
-        std::string   s( buffer + i, buffer_len- i < max_dbg_str_len ?
-          buffer_len - i : max_dbg_str_len );
-
-        ::OutputDebugStringA( s.c_str() );
-      }
-      return  true;
-    }
-
-  };
-#endif
-
-  inline bool is_stdout_a_tty()
-  {
-    static std::atomic<bool> initialized(false);
-    static std::atomic<bool> is_a_tty(false);
-
-    if (!initialized.load(std::memory_order_acquire))
-    {
-#if defined(WIN32)
-      is_a_tty.store(0 != _isatty(_fileno(stdout)), std::memory_order_relaxed);
-#else
-      is_a_tty.store(0 != isatty(fileno(stdout)), std::memory_order_relaxed);
-#endif
-      initialized.store(true, std::memory_order_release);
-    }
-
-    return is_a_tty.load(std::memory_order_relaxed);
-  }
-
-  inline void set_console_color(int color, bool bright)
-  {
-    if (!is_stdout_a_tty())
-      return;
-
-    switch(color)
-    {
-    case console_color_default:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE| (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;37m";
-        else
-          std::cout << "\033[0m";
-#endif
-      }
-      break;
-    case console_color_white:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;37m";
-        else
-          std::cout << "\033[0;37m";
-#endif
-      }
-      break;
-    case console_color_red:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;31m";
-        else
-          std::cout << "\033[0;31m";
-#endif
-      }
-      break;
-    case console_color_green:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;32m";
-        else
-          std::cout << "\033[0;32m";
-#endif
-      }
-      break;
-
-    case console_color_blue:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_BLUE | FOREGROUND_INTENSITY);//(bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;34m";
-        else
-          std::cout << "\033[0;34m";
-#endif
-      }
-      break;
-
-    case console_color_cyan:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | FOREGROUND_BLUE | (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;36m";
-        else
-          std::cout << "\033[0;36m";
-#endif
-      }
-      break;
-
-    case console_color_magenta:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_BLUE | FOREGROUND_RED | (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;35m";
-        else
-          std::cout << "\033[0;35m";
-#endif
-      }
-      break;
-
-    case console_color_yellow:
-      {
-#ifdef WIN32
-        HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | (bright ? FOREGROUND_INTENSITY:0));
-#else
-        if(bright)
-          std::cout << "\033[1;33m";
-        else
-          std::cout << "\033[0;33m";
-#endif
-      }
-      break;
-
-    }
-  }
-
-  inline void reset_console_color() {
-    if (!is_stdout_a_tty())
-      return;
-
-#ifdef WIN32
-    HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-    SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
-#else
-    std::cout << "\033[0m";
-    std::cout.flush();
-#endif
-  }
-
-  class console_output_stream: public ibase_log_stream
-  {
-#ifdef _MSC_VER
-    bool m_have_to_kill_console;
-#endif
-
-  public:
-    console_output_stream()
-    {
-#ifdef _MSC_VER
-
-      if(!::GetStdHandle(STD_OUTPUT_HANDLE))
-        m_have_to_kill_console = true;
-      else
-        m_have_to_kill_console = false;
-
-      ::AllocConsole();
-#endif
-    }
-
-    ~console_output_stream()
-    {
-#ifdef _MSC_VER
-      if(m_have_to_kill_console)
-        ::FreeConsole();
-#endif
-    }
-    int get_type(){return LOGGER_CONSOLE;}
-
-
-
-    virtual bool out_buffer( const char* buffer, int buffer_len , int log_level, int color, const char* plog_name = NULL)
-    {
-      if(plog_name)
-        return true; //skip alternative logs from console
-
-      set_console_color(color, log_level < 1);
-
-#ifdef _MSC_VER
-      const char* ptarget_buf = NULL;
-      char* pallocated_buf = NULL;
-
-      //
-      int i = 0;
-      for(; i < buffer_len; i++)
-        if(buffer[i] == '\a') break;
-      if(i == buffer_len)
-        ptarget_buf = buffer;
-      else
-      {
-        pallocated_buf = new char[buffer_len];
-        ptarget_buf = pallocated_buf;
-        for(i = 0; i < buffer_len; i++)
-        {
-          if(buffer[i] == '\a')
-            pallocated_buf[i] = '^';
-          else
-            pallocated_buf[i] = buffer[i];
-        }
-      }
-
-      //uint32_t b = 0;
-      //::WriteConsoleA(::GetStdHandle(STD_OUTPUT_HANDLE), ptarget_buf, buffer_len, (DWORD*)&b, 0);
-      std::cout << ptarget_buf;
-      if(pallocated_buf) delete [] pallocated_buf;
-#else
-      std::string buf(buffer, buffer_len);
-      for(size_t i = 0; i!= buf.size(); i++)
-      {
-        if(buf[i] == 7 || (buf[i]&0xff) == 0x95)
-          buf[i] = '^';
-      }
-
-      std::cout << buf;
-      std::cout << std::flush;
-#endif
-      reset_console_color();
-      return  true;
-    }
-
-
-  };
-
-  inline bool rotate_log_file(const char* pfile_path)
-  {
-#ifdef _MSC_VER
-    if(!pfile_path)
-      return false;
-
-    std::string file_path = pfile_path;
-    std::string::size_type a = file_path .rfind('.');
-    if ( a != std::string::npos )
-      file_path .erase( a, file_path .size());
-
-    ::DeleteFileA( (file_path + ".0").c_str() );
-    ::MoveFileA( (file_path + ".log").c_str(), (file_path + ".0").c_str() );
-#else
-    return false;//not implemented yet
-#endif
-    return true;
-  }
-
-
-
-
-  //--------------------------------------------------------------------------//
-  class file_output_stream : public ibase_log_stream
-  {
-  public:
-    typedef std::map<std::string, std::ofstream*> named_log_streams;
-
-    file_output_stream( std::string default_log_file_name, std::string log_path )
-    {
-      m_default_log_filename = default_log_file_name;
-      m_max_logfile_size = 0;
-      m_default_log_path = log_path;
-      m_pdefault_file_stream = add_new_stream_and_open(default_log_file_name.c_str());
-    }
-
-    ~file_output_stream()
-    {
-      for(named_log_streams::iterator it = m_log_file_names.begin(); it!=m_log_file_names.end(); it++)
-      {
-        if ( it->second->is_open() )
-        {
-          it->second->flush();
-          it->second->close();
-        }
-        delete it->second;
-      }
-    }
-  private:
-    named_log_streams m_log_file_names;
-    std::string       m_default_log_path;
-    std::ofstream*    m_pdefault_file_stream;
-    std::string     m_log_rotate_cmd;
-    std::string     m_default_log_filename;
-    uint64_t   m_max_logfile_size;
-
-
-    std::ofstream*    add_new_stream_and_open(const char* pstream_name)
-    {
-      //log_space::rotate_log_file((m_default_log_path + "\\" + pstream_name).c_str());
-
-      std::ofstream* pstream = (m_log_file_names[pstream_name] = new std::ofstream);
-      std::string target_path = m_default_log_path + "/" + pstream_name;
-      pstream->open( target_path.c_str(), std::ios_base::out | std::ios::app /*ios_base::trunc */);
-      if(pstream->fail())
-        return NULL;
-      return pstream;
-    }
-
-    bool set_max_logfile_size(uint64_t max_size)
-    {
-      m_max_logfile_size = max_size;
-      return true;
-    }
-
-    bool set_log_rotate_cmd(const std::string& cmd)
-    {
-      m_log_rotate_cmd = cmd;
-      return true;
-    }
-
-
-
-    virtual bool out_buffer( const char* buffer, int buffer_len, int log_level, int color, const char* plog_name = NULL )
-    {
-      std::ofstream*    m_target_file_stream = m_pdefault_file_stream;
-      if(plog_name)
-      { //find named stream
-        named_log_streams::iterator it = m_log_file_names.find(plog_name);
-        if(it == m_log_file_names.end())
-          m_target_file_stream = add_new_stream_and_open(plog_name);
-        else
-          m_target_file_stream = it->second;
-      }
-      if(!m_target_file_stream || !m_target_file_stream->is_open())
-        return false;//TODO: add assert here
-
-      m_target_file_stream->write(buffer, buffer_len );
-      m_target_file_stream->flush();
-
-      if(m_max_logfile_size)
-      {
-        std::ofstream::pos_type pt =  m_target_file_stream->tellp();
-        uint64_t current_sz = pt;
-        if(current_sz > m_max_logfile_size)
-        {
-          std::cout << "current_sz= " << current_sz << " m_max_logfile_size= " << m_max_logfile_size << std::endl;
-          std::string log_file_name;
-          if(!plog_name)
-            log_file_name = m_default_log_filename;
-          else
-            log_file_name = plog_name;
-
-          m_target_file_stream->close();
-          std::string new_log_file_name = log_file_name;
-
-          time_t tm = 0;
-          time(&tm);
-
-          int err_count = 0;
-          boost::system::error_code ec;
-          do
-          {
-            new_log_file_name = string_tools::cut_off_extension(log_file_name);
-            if(err_count)
-              new_log_file_name += misc_utils::get_time_str_v2(tm) + "(" + boost::lexical_cast<std::string>(err_count) + ")" + ".log";
-            else
-              new_log_file_name += misc_utils::get_time_str_v2(tm) + ".log";
-
-            err_count++;
-          }while(boost::filesystem::exists(m_default_log_path + "/" + new_log_file_name, ec));
-
-          std::string new_log_file_path = m_default_log_path + "/" + new_log_file_name;
-          boost::filesystem::rename(m_default_log_path + "/" + log_file_name, new_log_file_path, ec);
-          if(ec)
-          {
-            std::cout << "Filed to rename, ec = " << ec.message() << std::endl;
-          }
-
-          if(m_log_rotate_cmd.size())
-          {
-
-            std::string m_log_rotate_cmd_local_copy = m_log_rotate_cmd;
-            //boost::replace_all(m_log_rotate_cmd, "[*SOURCE*]", new_log_file_path);
-            boost::replace_all(m_log_rotate_cmd_local_copy, "[*TARGET*]", new_log_file_path);
-
-            misc_utils::call_sys_cmd(m_log_rotate_cmd_local_copy);
-          }
-
-          m_target_file_stream->open( (m_default_log_path + "/" + log_file_name).c_str(), std::ios_base::out | std::ios::app /*ios_base::trunc */);
-          if(m_target_file_stream->fail())
-            return false;
-        }
-      }
-
-      return  true;
-    }
-    int get_type(){return LOGGER_FILE;}
-  };
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  class log_stream_splitter
-  {
-  public:
-    typedef std::list<std::pair<ibase_log_stream*, int> > streams_container;
-
-    log_stream_splitter(){}
-    ~log_stream_splitter()
-    {
-      //free pointers
-      std::for_each(m_log_streams.begin(), m_log_streams.end(), delete_ptr());
-    }
-
-    bool set_max_logfile_size(uint64_t max_size)
-    {
-      for(streams_container::iterator it = m_log_streams.begin(); it!=m_log_streams.end();it++)
-        it->first->set_max_logfile_size(max_size);
-      return true;
-    }
-
-    bool set_log_rotate_cmd(const std::string& cmd)
-    {
-      for(streams_container::iterator it = m_log_streams.begin(); it!=m_log_streams.end();it++)
-        it->first->set_log_rotate_cmd(cmd);
-      return true;
-    }
-
-    bool do_log_message(const std::string& rlog_mes, int log_level, int color, const char* plog_name = NULL)
-    {
-      std::string str_mess = rlog_mes;
-      size_t str_len = str_mess.size();
-      const char* pstr = str_mess.c_str();
-      for(streams_container::iterator it = m_log_streams.begin(); it!=m_log_streams.end();it++)
-        if(it->second >= log_level)
-          it->first->out_buffer(pstr, (int)str_len, log_level, color, plog_name);
-      return true;
-    }
-
-    bool add_logger( int type, const char* pdefault_file_name, const char* pdefault_log_folder, int log_level_limit = LOG_LEVEL_4 )
-    {
-      ibase_log_stream* ls = NULL;
-
-      switch( type )
-      {
-      case LOGGER_FILE:
-        ls = new file_output_stream( pdefault_file_name, pdefault_log_folder );
-        break;
-
-      case LOGGER_DEBUGGER:
-#ifdef _MSC_VER
-        ls = new debug_output_stream( );
-#else
-        return false;//not implemented yet
-#endif
-        break;
-      case LOGGER_CONSOLE:
-        ls = new console_output_stream( );
-        break;
-      }
-
-      if ( ls ) {
-        m_log_streams.push_back(streams_container::value_type(ls, log_level_limit));
-        return true;
-      }
-      return ls ? true:false;
-    }
-    bool add_logger( ibase_log_stream* pstream, int log_level_limit = LOG_LEVEL_4 )
-    {
-      m_log_streams.push_back(streams_container::value_type(pstream, log_level_limit) );
-      return true;
-    }
-
-    bool remove_logger(int type)
-    {
-      streams_container::iterator it = m_log_streams.begin();
-      for(;it!=m_log_streams.end(); it++)
-      {
-        if(it->first->get_type() == type)
-        {
-          delete it->first;
-          m_log_streams.erase(it);
-          return true;
-        }
-      }
-      return false;
-
-    }
-
-  protected:
-  private:
-
-        streams_container m_log_streams;
-  };
-
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  inline int get_set_log_detalisation_level(bool is_need_set = false, int log_level_to_set = LOG_LEVEL_1);
-  inline int  get_set_time_level(bool is_need_set = false, int time_log_level = LOG_LEVEL_0);
-  inline bool get_set_need_thread_id(bool is_need_set = false, bool is_need_val = false);
-  inline bool get_set_need_proc_name(bool is_need_set = false, bool is_need_val = false);
-
-
-  inline std::string get_daytime_string2()
-  {
-    boost::posix_time::ptime p = boost::posix_time::microsec_clock::local_time();
-    return misc_utils::get_time_str_v3(p);
-  }
-  inline std::string get_day_time_string()
-  {
-    return get_daytime_string2();
-    //time_t tm = 0;
-    //time(&tm);
-    //return  misc_utils::get_time_str(tm);
-  }
-
-  inline std::string get_time_string()
-  {
-            return get_daytime_string2();
-
-  }
-#ifdef _MSC_VER
-  inline std::string get_time_string_adv(SYSTEMTIME* pst = NULL)
-  {
-    SYSTEMTIME st = {0};
-    if(!pst)
-    {
-      pst = &st;
-      GetSystemTime(&st);
-    }
-    std::stringstream str_str;
-    str_str.fill('0');
-    str_str << std::setw(2) << pst->wHour << "_"
-        << std::setw(2) << pst->wMinute << "_"
-        << std::setw(2) << pst->wSecond << "_"
-        << std::setw(3) << pst->wMilliseconds;
-    return str_str.str();
-  }
-#endif
-
-
-
-
-
-    class logger
-  {
-  public:
-    friend class log_singletone;
-
-    logger()
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      init();
-      CRITICAL_REGION_END();
-    }
-    ~logger()
-    {
-    }
-
-    bool set_max_logfile_size(uint64_t max_size)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      m_log_target.set_max_logfile_size(max_size);
-      CRITICAL_REGION_END();
-      return true;
-    }
-
-    bool set_log_rotate_cmd(const std::string& cmd)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      m_log_target.set_log_rotate_cmd(cmd);
-      CRITICAL_REGION_END();
-      return true;
-    }
-
-    bool take_away_journal(std::list<std::string>& journal)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      m_journal.swap(journal);
-      CRITICAL_REGION_END();
-      return true;
-    }
-
-    bool do_log_message(const std::string& rlog_mes, int log_level, int color, bool add_to_journal = false, const char* plog_name = NULL)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      m_log_target.do_log_message(rlog_mes, log_level, color, plog_name);
-      if(add_to_journal)
-        m_journal.push_back(rlog_mes);
-
-      return true;
-      CRITICAL_REGION_END();
-    }
-
-    bool add_logger( int type, const char* pdefault_file_name, const char* pdefault_log_folder , int log_level_limit = LOG_LEVEL_4)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      return m_log_target.add_logger( type, pdefault_file_name, pdefault_log_folder, log_level_limit);
-      CRITICAL_REGION_END();
-    }
-    bool add_logger( ibase_log_stream* pstream, int log_level_limit = LOG_LEVEL_4)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      return m_log_target.add_logger(pstream, log_level_limit);
-      CRITICAL_REGION_END();
-    }
-
-    bool remove_logger(int type)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      return m_log_target.remove_logger(type);
-      CRITICAL_REGION_END();
-    }
-
-
-    bool set_thread_prefix(const std::string& prefix)
-    {
-      CRITICAL_REGION_BEGIN(m_critical_sec);
-      m_thr_prefix_strings[misc_utils::get_thread_string_id()] = prefix;
-      CRITICAL_REGION_END();
-      return true;
-    }
-
-
-    std::string get_default_log_file()
-    {
-      return m_default_log_file;
-    }
-
-    std::string get_default_log_folder()
-    {
-      return m_default_log_folder;
-    }
-
-  protected:
-  private:
-    bool init()
-    {
-      //
-
-      m_process_name = string_tools::get_current_module_name();
-
-      init_log_path_by_default();
-
-      //init default set of loggers
-      init_default_loggers();
-
-      std::stringstream ss;
-      ss  << get_time_string() << " Init logging. Level=" << get_set_log_detalisation_level()
-        << " Log path=" << m_default_log_folder << std::endl;
-      this->do_log_message(ss.str(), console_color_white, LOG_LEVEL_0);
-      return true;
-    }
-    bool init_default_loggers()
-    {
-      //TODO:
-      return true;
-    }
-
-    bool init_log_path_by_default()
-    {
-      //load process name
-      m_default_log_folder = string_tools::get_current_module_folder();
-
-      m_default_log_file =  m_process_name;
-      std::string::size_type a = m_default_log_file.rfind('.');
-      if ( a != std::string::npos )
-        m_default_log_file.erase( a, m_default_log_file.size());
-      if ( ! m_default_log_file.empty() )
-        m_default_log_file += ".log";
-
-      return true;
-    }
-
-    log_stream_splitter m_log_target;
-
-    std::string m_default_log_folder;
-    std::string m_default_log_file;
-    std::string m_process_name;
-    std::map<std::string, std::string> m_thr_prefix_strings;
-    std::list<std::string> m_journal;
-    critical_section m_critical_sec;
-  };
-  /************************************************************************/
-  /*                                                                      */
-  /************************************************************************/
-  class log_singletone
-  {
-  public:
-    friend class initializer<log_singletone>;
-    friend class logger;
-    static int get_log_detalisation_level()
-    {
-      get_or_create_instance();//to initialize logger, if it not initialized
-      return get_set_log_detalisation_level();
-    }
-
-    static bool is_filter_error(int error_code)
-    {
-      return false;
-    }
-
-
-    static bool do_log_message(const std::string& rlog_mes, int log_level, int color, bool keep_in_journal, const char* plog_name = NULL)
-    {
-      logger* plogger = get_or_create_instance();
-      bool res = false;
-      if(plogger)
-        res = plogger->do_log_message(rlog_mes, log_level, color, keep_in_journal, plog_name);
-      else
-      { //globally uninitialized, create new logger for each call of do_log_message() and then delete it
-        plogger = new logger();
-        //TODO: some extra initialization
-        res = plogger->do_log_message(rlog_mes, log_level, color, keep_in_journal, plog_name);
-        delete plogger;
-        plogger = NULL;
-      }
-      return res;
-    }
-
-    static bool take_away_journal(std::list<std::string>& journal)
-    {
-      logger* plogger = get_or_create_instance();
-      bool res = false;
-      if(plogger)
-        res = plogger->take_away_journal(journal);
-
-      return res;
-    }
-
-    static bool set_max_logfile_size(uint64_t file_size)
-    {
-      logger* plogger = get_or_create_instance();
-      if(!plogger) return false;
-      return plogger->set_max_logfile_size(file_size);
-    }
-
-
-    static bool set_log_rotate_cmd(const std::string& cmd)
-    {
-      logger* plogger = get_or_create_instance();
-      if(!plogger) return false;
-      return plogger->set_log_rotate_cmd(cmd);
-    }
-
-
-    static bool add_logger( int type, const char* pdefault_file_name, const char* pdefault_log_folder, int log_level_limit = LOG_LEVEL_4)
-    {
-      logger* plogger = get_or_create_instance();
-      if(!plogger) return false;
-      return plogger->add_logger(type, pdefault_file_name, pdefault_log_folder, log_level_limit);
-    }
-
-    static std::string get_default_log_file()
-    {
-      logger* plogger = get_or_create_instance();
-      if(plogger)
-        return plogger->get_default_log_file();
-
-      return "";
-    }
-
-    static std::string get_default_log_folder()
-    {
-      logger* plogger = get_or_create_instance();
-      if(plogger)
-        return plogger->get_default_log_folder();
-
-      return "";
-    }
-
-    static bool add_logger( ibase_log_stream* pstream, int log_level_limit = LOG_LEVEL_4 )
-    {
-      logger* plogger = get_or_create_instance();
-      if(!plogger) return false;
-      return plogger->add_logger(pstream, log_level_limit);
-    }
-
-
-    static bool remove_logger( int type )
-    {
-      logger* plogger = get_or_create_instance();
-      if(!plogger) return false;
-      return plogger->remove_logger(type);
-    }
-PUSH_WARNINGS
-DISABLE_GCC_WARNING(maybe-uninitialized)
-    static int get_set_log_detalisation_level(bool is_need_set = false, int log_level_to_set = LOG_LEVEL_1)
-    {
-      static int log_detalisation_level = LOG_LEVEL_1;
-      if(is_need_set)
-        log_detalisation_level = log_level_to_set;
-      return log_detalisation_level;
-    }
-POP_WARNINGS
-    static int  get_set_time_level(bool is_need_set = false, int time_log_level = LOG_LEVEL_0)
-    {
-      static int val_time_log_level = LOG_LEVEL_0;
-      if(is_need_set)
-        val_time_log_level = time_log_level;
-
-      return val_time_log_level;
-    }
-
-    static int  get_set_process_level(bool is_need_set = false, int process_log_level = LOG_LEVEL_0)
-    {
-      static int val_process_log_level = LOG_LEVEL_0;
-      if(is_need_set)
-        val_process_log_level = process_log_level;
-
-      return val_process_log_level;
-    }
-
-    /*static int  get_set_tid_level(bool is_need_set = false, int tid_log_level = LOG_LEVEL_0)
-    {
-      static int val_tid_log_level = LOG_LEVEL_0;
-      if(is_need_set)
-        val_tid_log_level = tid_log_level;
-
-      return val_tid_log_level;
-    }*/
-
-    static bool get_set_need_thread_id(bool is_need_set = false, bool is_need_val = false)
-    {
-      static bool is_need = false;
-      if(is_need_set)
-        is_need = is_need_val;
-
-      return is_need;
-    }
-
-    static bool get_set_need_proc_name(bool is_need_set = false, bool is_need_val = false)
-    {
-      static bool is_need = true;
-      if(is_need_set)
-        is_need = is_need_val;
-
-      return is_need;
-    }
-    static uint64_t get_set_err_count(bool is_need_set = false, uint64_t err_val = false)
-    {
-      static uint64_t err_count = 0;
-      if(is_need_set)
-        err_count = err_val;
-
-      return err_count;
-    }
-
-
-#ifdef _MSC_VER
-
-
-    static void SetThreadName( DWORD dwThreadID, const char* threadName)
-    {
-#define MS_VC_EXCEPTION 0x406D1388
-
-#pragma pack(push,8)
-      typedef struct tagTHREADNAME_INFO
-      {
-        DWORD dwType; // Must be 0x1000.
-        LPCSTR szName; // Pointer to name (in user addr space).
-        DWORD dwThreadID; // Thread ID (-1=caller thread).
-        DWORD dwFlags; // Reserved for future use, must be zero.
-      } THREADNAME_INFO;
-#pragma pack(pop)
-
-
-
-      Sleep(10);
-      THREADNAME_INFO info;
-      info.dwType = 0x1000;
-      info.szName = (char*)threadName;
-      info.dwThreadID = dwThreadID;
-      info.dwFlags = 0;
-
-      __try
-      {
-        RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
-      }
-      __except(EXCEPTION_EXECUTE_HANDLER)
-      {
-      }
-    }
-#endif
-
-    static bool set_thread_log_prefix(const std::string& prefix)
-    {
-#ifdef _MSC_VER
-      SetThreadName(-1, prefix.c_str());
-#endif
-
-
-      logger* plogger = get_or_create_instance();
-      if(!plogger) return false;
-      return plogger->set_thread_prefix(prefix);
-    }
-
-
-    static std::string get_prefix_entry()
-    {
-      std::stringstream str_prefix;
-      //write time entry
-      if ( get_set_time_level() <= get_set_log_detalisation_level() )
-        str_prefix << get_day_time_string() << " ";
-
-      //write process info
-      logger* plogger = get_or_create_instance();
-      //bool res = false;
-      if(!plogger)
-      { //globally uninitialized, create new logger for each call of get_prefix_entry() and then delete it
-        plogger = new logger();
-      }
-
-      //if ( get_set_need_proc_name() && get_set_process_level() <= get_set_log_detalisation_level()  )
-      //    str_prefix << "[" << plogger->m_process_name << " (id=" << GetCurrentProcessId() << ")] ";
-//#ifdef _MSC_VER_EX
-      if ( get_set_need_thread_id() /*&& get_set_tid_level() <= get_set_log_detalisation_level()*/ )
-        str_prefix << "tid:" << misc_utils::get_thread_string_id() << " ";
-//#endif
-
-      if(plogger->m_thr_prefix_strings.size())
-      {
-        CRITICAL_REGION_LOCAL(plogger->m_critical_sec);
-        std::string thr_str = misc_utils::get_thread_string_id();
-        std::map<std::string, std::string>::iterator it = plogger->m_thr_prefix_strings.find(thr_str);
-        if(it!=plogger->m_thr_prefix_strings.end())
-        {
-          str_prefix << it->second;
-        }
-      }
-
-
-      if(get_set_is_uninitialized())
-        delete plogger;
-
-      return str_prefix.str();
-    }
-
-  private:
-    log_singletone(){}//restric to create an instance
-    //static initializer<log_singletone> m_log_initializer;//must be in one .cpp file (for example main.cpp) via DEFINE_LOGGING macro
-
-    static bool init()
-    {
-      return true;/*do nothing here*/
-    }
-    static bool un_init()
-    {
-      //delete object
-      logger* plogger = get_set_instance_internal();
-      if(plogger) delete plogger;
-      //set uninitialized
-      get_set_is_uninitialized(true, true);
-      get_set_instance_internal(true, NULL);
-      return true;
-    }
-
-    static logger* get_or_create_instance()
-    {
-      logger* plogger = get_set_instance_internal();
-      if(!plogger)
-        if(!get_set_is_uninitialized())
-          get_set_instance_internal(true, plogger = new logger);
-
-      return plogger;
-    }
-
-    static logger* get_set_instance_internal(bool is_need_set = false, logger* pnew_logger_val = NULL)
-    {
-      static logger* val_plogger = NULL;
-
-      if(is_need_set)
-        val_plogger = pnew_logger_val;
-
-      return val_plogger;
-    }
-
-    static bool get_set_is_uninitialized(bool is_need_set = false, bool is_uninitialized = false)
-    {
-      static bool val_is_uninitialized = false;
-
-      if(is_need_set)
-        val_is_uninitialized = is_uninitialized;
-
-      return val_is_uninitialized;
-    }
-    //static int get_set_error_filter(bool is_need_set = false)
-  };
-
-  const static initializer<log_singletone> log_initializer;
-  /************************************************************************/
-  /*                                                                      */
-//  /************************************************************************/
-//  class log_array_value
-//  {
-//    int       num;
-//    log_message&    m_ref_log_mes;
-//
-//  public:
-//
-//    log_array_value( log_message& log_mes ) : num(0), m_ref_log_mes(log_mes) {}
-//
-//    void operator ( )( ibase_log_value *val ) {
-//      m_ref_log_mes << "\n[" << num++ << "] "/* << val*/; }
-//
-//
-//    template<class T>
-//      void operator ()(T &value )
-//    {
-//      m_ref_log_mes << "\n[" << num++ << "] " << value;
-//    }
-//  };
-
-  class log_frame
-  {
-    std::string   m_name;
-    int       m_level;
-    const char*           m_plog_name;
-  public:
-
-    log_frame(const std::string& name,  int dlevel = LOG_LEVEL_2 , const char* plog_name = NULL)
-    {
-#ifdef _MSC_VER
-      int lasterr=::GetLastError();
-#endif
-      m_plog_name = plog_name;
-      if ( dlevel <= log_singletone::get_log_detalisation_level() )
-      {
-        m_name = name;
-        std::stringstream ss;
-        ss << log_space::log_singletone::get_prefix_entry() << "-->>" << m_name << std::endl;
-        log_singletone::do_log_message(ss.str(), dlevel, console_color_default, false, m_plog_name);
-      }
-      m_level = dlevel;
-#ifdef _MSC_VER
-      ::SetLastError(lasterr);
-#endif
-    }
-    ~log_frame()
-    {
-#ifdef _MSC_VER
-      int lasterr=::GetLastError();
-#endif
-
-      if (m_level <= log_singletone::get_log_detalisation_level() )
-      {
-        std::stringstream ss;
-        ss << log_space::log_singletone::get_prefix_entry() << "<<--" << m_name << std::endl;
-        log_singletone::do_log_message(ss.str(), m_level, console_color_default, false,m_plog_name);
-      }
-#ifdef _MSC_VER
-      ::SetLastError(lasterr);
-#endif
-    }
-  };
-
-  inline int  get_set_time_level(bool is_need_set, int time_log_level)
-  {
-    return log_singletone::get_set_time_level(is_need_set, time_log_level);
-  }
-  inline int get_set_log_detalisation_level(bool is_need_set, int log_level_to_set)
-  {
-    return log_singletone::get_set_log_detalisation_level(is_need_set, log_level_to_set);
-  }
-  inline std::string get_prefix_entry()
-  {
-    return log_singletone::get_prefix_entry();
-  }
-  inline bool get_set_need_thread_id(bool is_need_set, bool is_need_val)
-  {
-    return log_singletone::get_set_need_thread_id(is_need_set, is_need_val);
-  }
-  inline bool get_set_need_proc_name(bool is_need_set, bool is_need_val )
-  {
-    return log_singletone::get_set_need_proc_name(is_need_set, is_need_val);
-  }
-
-  inline std::string get_win32_err_descr(int err_no)
-  {
-#ifdef _MSC_VER
-    LPVOID lpMsgBuf;
-
-    FormatMessageA(
-      FORMAT_MESSAGE_ALLOCATE_BUFFER |
-      FORMAT_MESSAGE_FROM_SYSTEM,
-      NULL,
-      err_no,
-      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-      (char*) &lpMsgBuf,
-      0, NULL );
-
-    std::string fix_sys_message = "(null)";
-    if(lpMsgBuf) fix_sys_message = (char*)lpMsgBuf;
-    std::string::size_type a;
-    if ( (a = fix_sys_message.rfind( '\n' )) != std::string::npos )
-      fix_sys_message.erase(a);
-    if ( (a = fix_sys_message.rfind( '\r' )) != std::string::npos )
-      fix_sys_message.erase(a);
-
-    LocalFree(lpMsgBuf);
-    return fix_sys_message;
-#else
-    return "Not implemented yet";
-#endif
-  }
-
-  inline bool getwin32_err_text(std::stringstream& ref_message, int error_no)
-  {
-    ref_message << "win32 error:" << get_win32_err_descr(error_no);
-    return true;
-  }
-}
-#if defined(_DEBUG) || defined(__GNUC__)
-  #define  ENABLE_LOGGING_INTERNAL
-#endif
 
-#if defined(ENABLE_RELEASE_LOGGING)
-  #define  ENABLE_LOGGING_INTERNAL
-#endif
-
-
-#if defined(ENABLE_LOGGING_INTERNAL)
-
-#define LOG_PRINT_NO_PREFIX2(log_name, x, y) do {if ( y <= epee::log_space::log_singletone::get_log_detalisation_level() )\
-  {std::stringstream ss________; ss________ << x << std::endl; epee::log_space::log_singletone::do_log_message(ss________.str() , y, epee::log_space::console_color_default, false, log_name);}} while(0)
-
-#define LOG_PRINT_NO_PREFIX_NO_POSTFIX2(log_name, x, y) do {if ( y <= epee::log_space::log_singletone::get_log_detalisation_level() )\
-  {std::stringstream ss________; ss________ << x; epee::log_space::log_singletone::do_log_message(ss________.str(), y, epee::log_space::console_color_default, false, log_name);}} while(0)
-
-
-#define LOG_PRINT_NO_POSTFIX2(log_name, x, y) do {if ( y <= epee::log_space::log_singletone::get_log_detalisation_level() )\
-  {std::stringstream ss________; ss________ << epee::log_space::log_singletone::get_prefix_entry() << x; epee::log_space::log_singletone::do_log_message(ss________.str(), y, epee::log_space::console_color_default, false, log_name);}} while(0)
-
-
-#define LOG_PRINT2(log_name, x, y) do {if ( y <= epee::log_space::log_singletone::get_log_detalisation_level() )\
-  {std::stringstream ss________; ss________ << epee::log_space::log_singletone::get_prefix_entry() << x << std::endl;epee::log_space::log_singletone::do_log_message(ss________.str(), y, epee::log_space::console_color_default, false, log_name);}} while(0)
-
-#define LOG_PRINT_COLOR2(log_name, x, y, color) do {if ( y <= epee::log_space::log_singletone::get_log_detalisation_level() )\
-  {std::stringstream ss________; ss________ << epee::log_space::log_singletone::get_prefix_entry() << x << std::endl;epee::log_space::log_singletone::do_log_message(ss________.str(), y, color, false, log_name);}} while(0)
-
-
-#define LOG_PRINT2_JORNAL(log_name, x, y) do {if ( y <= epee::log_space::log_singletone::get_log_detalisation_level() )\
-  {std::stringstream ss________; ss________ << epee::log_space::log_singletone::get_prefix_entry() << x << std::endl;epee::log_space::log_singletone::do_log_message(ss________.str(), y, epee::log_space::console_color_default, true, log_name);}} while(0)
-
-
-#define LOG_ERROR2(log_name, x) do { \
-  std::stringstream ss________; ss________ << epee::log_space::log_singletone::get_prefix_entry() << "ERROR " << __FILE__ << ":" << __LINE__ << " " << x << std::endl; epee::log_space::log_singletone::do_log_message(ss________.str(), LOG_LEVEL_0, epee::log_space::console_color_red, true, log_name);LOCAL_ASSERT(0); epee::log_space::log_singletone::get_set_err_count(true, epee::log_space::log_singletone::get_set_err_count()+1);} while(0)
-
-#define LOG_FRAME2(log_name, x, y) epee::log_space::log_frame frame(x, y, log_name)
-
-#else
-
-
-#define LOG_PRINT_NO_PREFIX2(log_name, x, y) ((void)0)
-
-#define LOG_PRINT_NO_PREFIX_NO_POSTFIX2(log_name, x, y) ((void)0)
-
-#define LOG_PRINT_NO_POSTFIX2(log_name, x, y) ((void)0)
 
-#define LOG_PRINT_COLOR2(log_name, x, y, color) ((void)0)
-
-#define LOG_PRINT2_JORNAL(log_name, x, y) ((void)0)
-
-#define LOG_PRINT2(log_name, x, y) ((void)0)
-
-#define LOG_ERROR2(log_name, x) ((void)0)
-
-
-#define LOG_FRAME2(log_name, x, y) ((void)0)
-
-
-#endif
-
-
-#ifndef LOG_DEFAULT_TARGET
-  #define LOG_DEFAULT_TARGET    NULL
-#endif
-
-
-#define LOG_PRINT_NO_POSTFIX(mess, level) LOG_PRINT_NO_POSTFIX2(LOG_DEFAULT_TARGET, mess, level)
-#define LOG_PRINT_NO_PREFIX(mess, level)  LOG_PRINT_NO_PREFIX2(LOG_DEFAULT_TARGET, mess, level)
-#define LOG_PRINT_NO_PREFIX_NO_POSTFIX(mess, level) LOG_PRINT_NO_PREFIX_NO_POSTFIX2(LOG_DEFAULT_TARGET, mess, level)
-#define LOG_PRINT(mess, level)        LOG_PRINT2(LOG_DEFAULT_TARGET, mess, level)
-
-#define LOG_PRINT_COLOR(mess, level, color)       LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, color)
-#define LOG_PRINT_RED(mess, level)        LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_red)
-#define LOG_PRINT_GREEN(mess, level)        LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_green)
-#define LOG_PRINT_BLUE(mess, level)       LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_blue)
-#define LOG_PRINT_YELLOW(mess, level)       LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_yellow)
-#define LOG_PRINT_CYAN(mess, level)       LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_cyan)
-#define LOG_PRINT_MAGENTA(mess, level)       LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_magenta)
-
-#define LOG_PRINT_RED_L0(mess)    LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, LOG_LEVEL_0, epee::log_space::console_color_red)
-#define LOG_PRINT_RED_L1(mess)    LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, LOG_LEVEL_1, epee::log_space::console_color_red)
-
-#define LOG_PRINT_L0(mess)        LOG_PRINT(mess, LOG_LEVEL_0)
-#define LOG_PRINT_L1(mess)        LOG_PRINT(mess, LOG_LEVEL_1)
-#define LOG_PRINT_L2(mess)        LOG_PRINT(mess, LOG_LEVEL_2)
-#define LOG_PRINT_L3(mess)        LOG_PRINT(mess, LOG_LEVEL_3)
-#define LOG_PRINT_L4(mess)        LOG_PRINT(mess, LOG_LEVEL_4)
-#define LOG_PRINT_J(mess, level)        LOG_PRINT2_JORNAL(LOG_DEFAULT_TARGET, mess, level)
-
-#define LOG_ERROR(mess)           LOG_ERROR2(LOG_DEFAULT_TARGET, mess)
-#define LOG_FRAME(mess, level)        LOG_FRAME2(LOG_DEFAULT_TARGET, mess, level)
-#define LOG_VALUE(mess, level)        LOG_VALUE2(LOG_DEFAULT_TARGET, mess, level)
-#define LOG_ARRAY(mess, level)        LOG_ARRAY2(LOG_DEFAULT_TARGET, mess, level)
-//#define LOGWIN_PLATFORM_ERROR(err_no)       LOGWINDWOS_PLATFORM_ERROR2(LOG_DEFAULT_TARGET, err_no)
-#define LOG_SOCKET_ERROR(err_no)      LOG_SOCKET_ERROR2(LOG_DEFAULT_TARGET, err_no)
-//#define LOGWIN_PLATFORM_ERROR_UNCRITICAL(mess)  LOGWINDWOS_PLATFORM_ERROR_UNCRITICAL2(LOG_DEFAULT_TARGET, mess)
 
 #define ENDL std::endl
 
@@ -1435,8 +178,6 @@ POP_WARNINGS
 #define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
 #endif
 
-#define NOTHING
-
 #ifndef CHECK_AND_ASSERT_MES
 #define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
 #endif
@@ -1463,5 +204,21 @@ POP_WARNINGS
 #define CHECK_AND_ASSERT_MES2(expr, message)   do{if(!(expr)) {LOG_ERROR(message); };}while(0)
 #endif
 
+enum console_colors
+{
+  console_color_default,
+  console_color_white,
+  console_color_red,
+  console_color_green,
+  console_color_blue,
+  console_color_cyan,
+  console_color_magenta,
+  console_color_yellow
+};
+
+bool is_stdout_a_tty();
+void set_console_color(int color, bool bright);
+void reset_console_color();
+
 }
 #endif //_MISC_LOG_EX_H_