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.

CMakeLists.txt

@@ -170,7 +170,7 @@ endif()
 # elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*")
 #   set(BSDI TRUE)
 
-include_directories(src contrib/epee/include external "${CMAKE_BINARY_DIR}/version")
+include_directories(external/easylogging++ src contrib/epee/include external "${CMAKE_BINARY_DIR}/version")
 
 if(APPLE)
   include_directories(SYSTEM /usr/include/malloc)

Makefile

@@ -96,6 +96,14 @@ release-static-win32:
 	mkdir -p build/release
 	cd build/release && cmake -G "MSYS Makefiles" -D STATIC=ON -D ARCH="i686" -D BUILD_64=OFF -D CMAKE_BUILD_TYPE=Release -D CMAKE_TOOLCHAIN_FILE=../../cmake/32-bit-toolchain.cmake -D MSYS2_FOLDER=c:/msys32 ../.. && $(MAKE)
 
+custom:
+	mkdir -p build/custom
+	cd build/custom && cmake -D BUILD_TESTS=ON -D USE_LTO=OFF -D ARCH="x86-64" -D CMAKE_BUILD_TYPE=custom ../.. && $(MAKE)
+
+custom-test:
+	mkdir -p build/custom
+	cd build/custom && cmake -D BUILD_TESTS=ON -D USE_LTO=OFF -D ARCH="x86-64" -D CMAKE_BUILD_TYPE=custom ../.. && $(MAKE) all test
+
 clean:
 	@echo "WARNING: Back-up your wallet if it exists within ./build!" ; \
         read -r -p "This will destroy the build directory, continue (y/N)?: " CONTINUE; \

contrib/CMakeLists.txt

@@ -27,5 +27,4 @@
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 add_subdirectory(epee)
-add_subdirectory(otshell_utils)
 

contrib/epee/include/console_handler.h

@@ -277,11 +277,11 @@ namespace epee
     {
       if (!m_prompt.empty())
       {
-        epee::log_space::set_console_color(epee::log_space::console_color_yellow, true);
+        epee::set_console_color(epee::console_color_yellow, true);
         std::cout << m_prompt;
         if (' ' != m_prompt.back())
           std::cout << ' ';
-        epee::log_space::reset_console_color();
+        epee::reset_console_color();
         std::cout.flush();
       }
     }
@@ -310,7 +310,7 @@ namespace epee
           }
           if (!get_line_ret)
           {
-            LOG_PRINT("Failed to read line.", LOG_LEVEL_0);
+            MERROR("Failed to read line.");
           }
           string_tools::trim(command);
 

contrib/epee/include/net/abstract_tcp_server.h

@@ -38,6 +38,9 @@
 
 #pragma comment(lib, "Ws2_32.lib")
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 namespace epee 
 {
 namespace net_utils

contrib/epee/include/net/abstract_tcp_server2.h

@@ -55,9 +55,11 @@
 #include "net_utils_base.h"
 #include "syncobj.h"
 #include "../../../../src/p2p/connection_basic.hpp"
-#include "../../../../contrib/otshell_utils/utils.hpp"
 #include "../../../../src/p2p/network_throttle-detail.hpp"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 #define ABSTRACT_SERVER_SEND_QUE_MAX_COUNT 1000
 
 namespace epee

contrib/epee/include/net/abstract_tcp_server2.inl

@@ -51,9 +51,8 @@
 
 #include "../../../../src/cryptonote_core/cryptonote_core.h" // e.g. for the send_stop_signal()
 
-#include "../../../../contrib/otshell_utils/utils.hpp"
+#undef MONERO_DEFAULT_LOG_CATEGORY
-#include "../../../../src/p2p/data_logger.hpp"
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
-using namespace nOT::nUtils; // TODO
 
 #define CONNECTION_CLEANUP_TIME 30 // seconds
 
@@ -83,7 +82,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 		m_throttle_speed_in("speed_in", "throttle_speed_in"),
 		m_throttle_speed_out("speed_out", "throttle_speed_out")
   {
-    _info_c("net/sleepRPC", "test, connection constructor set m_connection_type="<<m_connection_type);
+    MINFO("test, connection constructor set m_connection_type="<<m_connection_type);
   }
 PRAGMA_WARNING_DISABLE_VS(4355)
   //---------------------------------------------------------------------------------
@@ -229,7 +228,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
   {
     TRY_ENTRY();
     boost::shared_ptr<connection<t_protocol_handler> >  back_connection_copy;
-    LOG_PRINT_L4("[sock " << socket_.native_handle() << "] release");
+    LOG_TRACE_CC(context, "[sock " << socket_.native_handle() << "] release");
     CRITICAL_REGION_BEGIN(m_self_refs_lock);
     CHECK_AND_ASSERT_MES(m_self_refs.size(), false, "[sock " << socket_.native_handle() << "] m_self_refs empty at connection<t_protocol_handler>::release() call");
     //erasing from container without additional copy can cause start deleting object, including m_self_refs
@@ -266,8 +265,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
       address = endpoint.address().to_string();
       port = boost::lexical_cast<std::string>(endpoint.port());
     }
-    _mark_c("net/kind" ,
+    MINFO(" connection type " << to_string( m_connection_type ) << " "
-        " connection type " << to_string( m_connection_type ) << " "
         << socket_.local_endpoint().address().to_string() << ":" << socket_.local_endpoint().port()
         << " <--> " << address << ":" << port);
   }
@@ -306,7 +304,6 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 				delay *= 0.5;
 				if (delay > 0) {
 					long int ms = (long int)(delay * 100);
-					epee::net_utils::data_logger::get_instance().add_data("sleep_down", ms);
 					boost::this_thread::sleep_for(boost::chrono::milliseconds(ms));
 				}
 			} while(delay > 0);
@@ -397,14 +394,14 @@ PRAGMA_WARNING_DISABLE_VS(4355)
         const t_safe chunksize_max = chunksize_good * 2 ;
 		const bool allow_split = (m_connection_type == e_connection_type_RPC) ? false : true; // do not split RPC data
 
-        ASRT(! (chunksize_max<0) ); // make sure it is unsigned before removin sign with cast:
+        CHECK_AND_ASSERT_MES(! (chunksize_max<0), false, "Negative chunksize_max" ); // make sure it is unsigned before removin sign with cast:
         long long unsigned int chunksize_max_unsigned = static_cast<long long unsigned int>( chunksize_max ) ;
 
         if (allow_split && (cb > chunksize_max_unsigned)) {
 			{ // LOCK: chunking
     		epee::critical_region_t<decltype(m_chunking_lock)> send_guard(m_chunking_lock); // *** critical *** 
 
-				_dbg3_c("net/out/size", "do_send() will SPLIT into small chunks, from packet="<<cb<<" B for ptr="<<ptr);
+				MDEBUG("do_send() will SPLIT into small chunks, from packet="<<cb<<" B for ptr="<<ptr);
 				t_safe all = cb; // all bytes to send 
 				t_safe pos = 0; // current sending position
 				// 01234567890 
@@ -419,39 +416,39 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 				while (pos < all) {
 					t_safe lenall = all-pos; // length from here to end
 					t_safe len = std::min( chunksize_good , lenall); // take a smaller part
-					ASRT(len<=chunksize_good);
+					CHECK_AND_ASSERT_MES(len<=chunksize_good, false, "len too large");
 					// pos=8; len=4; all=10;	len=3;
 
-                    ASRT(! (len<0) ); // check before we cast away sign:
+                    CHECK_AND_ASSERT_MES(! (len<0), false, "negative len"); // check before we cast away sign:
                     unsigned long long int len_unsigned = static_cast<long long int>( len );
-                    ASRT(len>0); // (redundand)
+                    CHECK_AND_ASSERT_MES(len>0, false, "len not strictly positive"); // (redundant)
-                    ASRT(len_unsigned < std::numeric_limits<size_t>::max());   // yeap we want strong < then max size, to be sure
+                    CHECK_AND_ASSERT_MES(len_unsigned < std::numeric_limits<size_t>::max(), false, "Invalid len_unsigned");   // yeap we want strong < then max size, to be sure
 					
 					void *chunk_start = ((char*)ptr) + pos;
-					_fact_c("net/out/size","chunk_start="<<chunk_start<<" ptr="<<ptr<<" pos="<<pos);
+					MDEBUG("chunk_start="<<chunk_start<<" ptr="<<ptr<<" pos="<<pos);
-					ASRT(chunk_start >= ptr); // not wrapped around address?
+					CHECK_AND_ASSERT_MES(chunk_start >= ptr, false, "Pointer wraparound"); // not wrapped around address?
 					//std::memcpy( (void*)buf, chunk_start, len);
 
-					_dbg3_c("net/out/size", "part of " << lenall << ": pos="<<pos << " len="<<len);
+					MDEBUG("part of " << lenall << ": pos="<<pos << " len="<<len);
 
 					bool ok = do_send_chunk(chunk_start, len); // <====== ***
 
 					all_ok = all_ok && ok;
 					if (!all_ok) {
-						_dbg1_c("net/out/size", "do_send() DONE ***FAILED*** from packet="<<cb<<" B for ptr="<<ptr);
+						MDEBUG("do_send() DONE ***FAILED*** from packet="<<cb<<" B for ptr="<<ptr);
-						_dbg1("do_send() SEND was aborted in middle of big package - this is mostly harmless "
+						MDEBUG("do_send() SEND was aborted in middle of big package - this is mostly harmless "
 							<< " (e.g. peer closed connection) but if it causes trouble tell us at #monero-dev. " << cb);
 						return false; // partial failure in sending
 					}
-					pos = pos+len; ASRT(pos >0);
+					pos = pos+len;
+					CHECK_AND_ASSERT_MES(pos >0, false, "pos <= 0");
 
 					// (in catch block, or uniq pointer) delete buf;
 				} // each chunk
 
-				_dbg3_c("net/out/size", "do_send() DONE SPLIT from packet="<<cb<<" B for ptr="<<ptr);
+				MDEBUG("do_send() DONE SPLIT from packet="<<cb<<" B for ptr="<<ptr);
-				_dbg3  (                "do_send() DONE SPLIT from packet="<<cb<<" B for ptr="<<ptr);
 
-                _info_c("net/sleepRPC", "do_send() m_connection_type = " << m_connection_type);
+                MDEBUG("do_send() m_connection_type = " << m_connection_type);
 
 				return all_ok; // done - e.g. queued - all the chunks of current do_send call
 			} // LOCK: chunking
@@ -505,15 +502,14 @@ PRAGMA_WARNING_DISABLE_VS(4355)
         }*/
 
         long int ms = 250 + (rand()%50);
-        _info_c("net/sleep", "Sleeping because QUEUE is FULL, in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<cb); // XXX debug sleep
+        MDEBUG("Sleeping because QUEUE is FULL, in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<cb); // XXX debug sleep
         m_send_que_lock.unlock();
         boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) );
         m_send_que_lock.lock();
         _dbg1("sleep for queue: " << ms);
 
         if (retry > retry_limit) {
-            _erro("send que size is more than ABSTRACT_SERVER_SEND_QUE_MAX_COUNT(" << ABSTRACT_SERVER_SEND_QUE_MAX_COUNT << "), shutting down connection");
+            MWARNING("send que size is more than ABSTRACT_SERVER_SEND_QUE_MAX_COUNT(" << ABSTRACT_SERVER_SEND_QUE_MAX_COUNT << "), shutting down connection");
-            //	_dbg1_c("net/sleep", "send que size is more than ABSTRACT_SERVER_SEND_QUE_MAX_COUNT(" << ABSTRACT_SERVER_SEND_QUE_MAX_COUNT << "), shutting down connection");
             shutdown();
             return false;
         }
@@ -525,10 +521,10 @@ PRAGMA_WARNING_DISABLE_VS(4355)
     if(m_send_que.size() > 1)
     { // active operation should be in progress, nothing to do, just wait last operation callback
         auto size_now = cb;
-        _info_c("net/out/size", "do_send() NOW just queues: packet="<<size_now<<" B, is added to queue-size="<<m_send_que.size());
+        MDEBUG("do_send() NOW just queues: packet="<<size_now<<" B, is added to queue-size="<<m_send_que.size());
         //do_send_handler_delayed( ptr , size_now ); // (((H))) // empty function
       
-      LOG_PRINT_L4("[sock " << socket_.native_handle() << "] Async send requested " << m_send_que.front().size());
+      LOG_TRACE_CC(context, "[sock " << socket_.native_handle() << "] Async send requested " << m_send_que.front().size());
     }
     else
     { // no active operation
@@ -540,11 +536,11 @@ PRAGMA_WARNING_DISABLE_VS(4355)
         }
 
         auto size_now = m_send_que.front().size();
-        _dbg1_c("net/out/size", "do_send() NOW SENSD: packet="<<size_now<<" B");
+        MDEBUG("do_send() NOW SENSD: packet="<<size_now<<" B");
         if (speed_limit_is_enabled())
 			do_send_handler_write( ptr , size_now ); // (((H)))
 
-        ASRT( size_now == m_send_que.front().size() );
+        CHECK_AND_ASSERT_MES( size_now == m_send_que.front().size(), false, "Unexpected queue size");
         boost::asio::async_write(socket_, boost::asio::buffer(m_send_que.front().data(), size_now ) ,
                                  //strand_.wrap(
                                  boost::bind(&connection<t_protocol_handler>::handle_write, self, _1, _2)
@@ -602,7 +598,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
   void connection<t_protocol_handler>::handle_write(const boost::system::error_code& e, size_t cb)
   {
     TRY_ENTRY();
-    LOG_PRINT_L4("[sock " << socket_.native_handle() << "] Async send calledback " << cb);
+    LOG_TRACE_CC(context, "[sock " << socket_.native_handle() << "] Async send calledback " << cb);
 
     if (e)
     {
@@ -635,10 +631,10 @@ PRAGMA_WARNING_DISABLE_VS(4355)
     {
       //have more data to send
 		auto size_now = m_send_que.front().size();
-		_dbg1_c("net/out/size", "handle_write() NOW SENDS: packet="<<size_now<<" B" <<", from  queue size="<<m_send_que.size());
+		MDEBUG("handle_write() NOW SENDS: packet="<<size_now<<" B" <<", from  queue size="<<m_send_que.size());
 		if (speed_limit_is_enabled())
 			do_send_handler_write_from_queue(e, m_send_que.front().size() , m_send_que.size()); // (((H)))
-		ASRT( size_now == m_send_que.front().size() );
+		CHECK_AND_ASSERT_MES( size_now == m_send_que.front().size(), void(), "Unexpected queue size");
 		boost::asio::async_write(socket_, boost::asio::buffer(m_send_que.front().data(), size_now) , 
         // strand_.wrap(
           boost::bind(&connection<t_protocol_handler>::handle_write, connection<t_protocol_handler>::shared_from_this(), _1, _2)
@@ -660,8 +656,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
   void connection<t_protocol_handler>::setRpcStation()
   {
     m_connection_type = e_connection_type_RPC; 
-    _fact_c("net/sleepRPC", "set m_connection_type = RPC ");
+    MDEBUG("set m_connection_type = RPC ");
-    _info_c("net/kind", "set m_connection_type = RPC ");
   }
 
 
@@ -735,7 +730,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
     acceptor_.listen();
     boost::asio::ip::tcp::endpoint binded_endpoint = acceptor_.local_endpoint();
     m_port = binded_endpoint.port();
-    _fact_c("net/RPClog", "start accept");
+    MDEBUG("start accept");
     new_connection_.reset(new connection<t_protocol_handler>(io_service_, m_config, m_sock_count, m_sock_number, m_pfilter, m_connection_type));
     acceptor_.async_accept(new_connection_->socket(),
       boost::bind(&boosted_tcp_server<t_protocol_handler>::handle_accept, this,
@@ -753,7 +748,7 @@ DISABLE_GCC_WARNING(maybe-uninitialized)
     uint32_t p = 0;
 
     if (port.size() && !string_tools::get_xtype_from_string(p, port)) {
-      LOG_ERROR("Failed to convert port no = " << port);
+      MERROR("Failed to convert port no = " << port);
       return false;
     }
     return this->init_server(p, address);
@@ -767,7 +762,7 @@ POP_WARNINGS
     uint32_t local_thr_index = boost::interprocess::ipcdetail::atomic_inc32(&m_thread_index); 
     std::string thread_name = std::string("[") + m_thread_name_prefix;
     thread_name += boost::to_string(local_thr_index) + "]";
-    log_space::log_singletone::set_thread_log_prefix(thread_name);
+    MLOG_SET_THREAD_NAME(thread_name);
     //   _fact("Thread name: " << m_thread_name_prefix);
     while(!m_stop_signal_sent)
     {
@@ -796,8 +791,7 @@ POP_WARNINGS
 		auto it = server_type_map.find(m_thread_name_prefix);
 		if (it==server_type_map.end()) throw std::runtime_error("Unknown prefix/server type:" + std::string(prefix_name));
     auto connection_type = it->second; // the value of type
-    _info_c("net/RPClog", "Set server type to: " << connection_type << " from name: " << m_thread_name_prefix);
+    MINFO("Set server type to: " << connection_type << " from name: " << m_thread_name_prefix << ", prefix_name = " << prefix_name);
-    _info_c("net/RPClog", "prefix_name = " << prefix_name);
   }
   //---------------------------------------------------------------------------------
   template<class t_protocol_handler>
@@ -812,7 +806,7 @@ POP_WARNINGS
     TRY_ENTRY();
     m_threads_count = threads_count;
     m_main_thread_id = boost::this_thread::get_id();
-    log_space::log_singletone::set_thread_log_prefix("[SRV_MAIN]");
+    MLOG_SET_THREAD_NAME("[SRV_MAIN]");
     add_idle_handler(boost::bind(&boosted_tcp_server::cleanup_connections, this), 5000);
     while(!m_stop_signal_sent)
     {
@@ -933,13 +927,12 @@ POP_WARNINGS
   template<class t_protocol_handler>
   void boosted_tcp_server<t_protocol_handler>::handle_accept(const boost::system::error_code& e)
   {
-	_fact_c("net/RPClog", "handle_accept");
+    MDEBUG("handle_accept");
     TRY_ENTRY();
     if (!e)
     {
 		if (m_connection_type == e_connection_type_RPC) {
-			_note_c("net/rpc", "New server for RPC connections");
+			MDEBUG("New server for RPC connections");
-			_fact_c("net/RPClog", "New server for RPC connections");
 			new_connection_->setRpcStation(); // hopefully this is not needed actually
 		}
 		connection_ptr conn(std::move(new_connection_));
@@ -965,7 +958,7 @@ POP_WARNINGS
     connection_ptr new_connection_l(new connection<t_protocol_handler>(io_service_, m_config, m_sock_count, m_sock_number, m_pfilter, m_connection_type) );
     connections_mutex.lock();
     connections_.push_back(std::make_pair(boost::get_system_time(), new_connection_l));
-    LOG_PRINT_L2("connections_ size now " << connections_.size());
+    MDEBUG("connections_ size now " << connections_.size());
     connections_mutex.unlock();
     boost::asio::ip::tcp::socket&  sock_ = new_connection_l->socket();
     
@@ -1069,7 +1062,7 @@ POP_WARNINGS
     connection_ptr new_connection_l(new connection<t_protocol_handler>(io_service_, m_config, m_sock_count, m_sock_number, m_pfilter, m_connection_type) );
     connections_mutex.lock();
     connections_.push_back(std::make_pair(boost::get_system_time(), new_connection_l));
-    LOG_PRINT_L2("connections_ size now " << connections_.size());
+    MDEBUG("connections_ size now " << connections_.size());
     connections_mutex.unlock();
     boost::asio::ip::tcp::socket&  sock_ = new_connection_l->socket();
     

contrib/epee/include/net/abstract_tcp_server_cp.h

@@ -42,6 +42,9 @@
 #include "net_utils_base.h"
 #include "pragma_comp_defs.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 #define LEVIN_DEFAULT_DATA_BUFF_SIZE       2000  
 
 namespace epee

contrib/epee/include/net/abstract_tcp_server_cp.inl

@@ -27,6 +27,9 @@
 
 #pragma comment(lib, "Ws2_32.lib")
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_auth.h

@@ -36,6 +36,9 @@
 
 #include "http_base.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_base.h

@@ -31,6 +31,10 @@
 #include <boost/regex.hpp>
 
 #include "string_tools.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_client.h

@@ -52,6 +52,9 @@
 
 //#pragma comment(lib, "shlwapi.lib")
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 extern epee::critical_section gregexp_lock;
 
 
@@ -325,10 +328,10 @@ using namespace std;
 				CRITICAL_REGION_LOCAL(m_lock);
 				if(!is_connected())
 				{
-					LOG_PRINT("Reconnecting...", LOG_LEVEL_3);
+					MDEBUG("Reconnecting...");
 					if(!connect(m_host_buff, m_port, m_timeout))
 					{
-						LOG_PRINT("Failed to connect to " << m_host_buff << ":" << m_port, LOG_LEVEL_3);
+						MDEBUG("Failed to connect to " << m_host_buff << ":" << m_port);
 						return false;
 					}
 				}
@@ -376,7 +379,7 @@ using namespace std;
 					{
 						if(!m_net_client.recv(recv_buffer))
 						{
-							LOG_PRINT("Unexpected reciec fail", LOG_LEVEL_3);
+							MERROR("Unexpected recv fail");
 							m_state = reciev_machine_state_error;
             }
             if(!recv_buffer.size())
@@ -464,7 +467,7 @@ using namespace std;
 				CRITICAL_REGION_LOCAL(m_lock);
 				if(!recv_buff.size())
 				{
-					LOG_PRINT("Warning: Content-Len mode, but connection unexpectedly closed", LOG_LEVEL_3);
+					MERROR("Warning: Content-Len mode, but connection unexpectedly closed");
 					m_state = reciev_machine_state_done;
 					return true;
 				}
@@ -578,7 +581,7 @@ using namespace std;
         CRITICAL_REGION_LOCAL(m_lock);
 				if(!recv_buff.size())
 				{
-					LOG_PRINT("Warning: CHUNKED mode, but connection unexpectedly closed", LOG_LEVEL_3);
+					MERROR("Warning: CHUNKED mode, but connection unexpectedly closed");
 					m_state = reciev_machine_state_done;
 					return true;
 				}
@@ -665,7 +668,7 @@ using namespace std;
 			inline
 				bool parse_header(http_header_info& body_info, const std::string& m_cache_to_process)
 			{ 
-				LOG_FRAME("http_stream_filter::parse_cached_header(*)", LOG_LEVEL_4);
+				MTRACE("http_stream_filter::parse_cached_header(*)");
 				
 				STATIC_REGEXP_EXPR_1(rexp_mach_field, 
 					"\n?((Connection)|(Referer)|(Content-Length)|(Content-Type)|(Transfer-Encoding)|(Content-Encoding)|(Host)|(Cookie)|(User-Agent)"
@@ -833,7 +836,7 @@ using namespace std;
 				}else
 				{   //Apparently there are no signs of the form of transfer, will receive data until the connection is closed
 					m_state = reciev_machine_state_error;
-					LOG_PRINT("Undefinded transfer type, consider http_body_transfer_connection_close method. header: " << m_header_cache, LOG_LEVEL_2);
+					MERROR("Undefinded transfer type, consider http_body_transfer_connection_close method. header: " << m_header_cache);
 					return false;
 				} 
 				return false;

contrib/epee/include/net/http_client_abstract_invoke.h

@@ -28,6 +28,9 @@
 #pragma once
 #include "storages/serializeble_struct_helper.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
   namespace net_utils

contrib/epee/include/net/http_client_base.h

@@ -26,6 +26,9 @@
 
 #pragma once 
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
   namespace net_utils

contrib/epee/include/net/http_client_via_api_helper.h

@@ -32,6 +32,9 @@
 #include <atlutil.h>
 #pragma comment(lib, "Wininet.lib")
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_protocol_handler.h

@@ -37,6 +37,9 @@
 #include "http_auth.h"
 #include "http_base.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_protocol_handler.inl

@@ -33,6 +33,9 @@
 #include "file_io_utils.h"
 #include "net_parse_helpers.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 #define HTTP_MAX_URI_LEN		 9000 
 #define HTTP_MAX_HEADER_LEN		 100000
 
@@ -133,7 +136,7 @@ namespace net_utils
 			std::string boundary;
 			if(!match_boundary(content_type, boundary))
 			{
-				LOG_PRINT("Failed to match boundary in content type: " << content_type, LOG_LEVEL_0);
+				MERROR("Failed to match boundary in content type: " << content_type);
 				return false;
 			}
 			
@@ -155,7 +158,7 @@ namespace net_utils
 					pos = body.find(boundary, std::distance(body.begin(), it_begin));
 					if(std::string::npos == pos)
 					{
-						LOG_PRINT("Error: Filed to match closing multipart tag", LOG_LEVEL_0);
+						MERROR("Error: Filed to match closing multipart tag");
 						it_end = body.end();
 					}else
 					{
@@ -177,7 +180,7 @@ namespace net_utils
 				out_values.push_back(multipart_entry());
 				if(!handle_part_of_multipart(it_begin, it_end, out_values.back()))
 				{
-					LOG_PRINT("Failed to handle_part_of_multipart", LOG_LEVEL_0);
+					MERROR("Failed to handle_part_of_multipart");
 					return false;
 				}
 
@@ -331,8 +334,6 @@ namespace net_utils
   template<class t_connection_context>
 	bool simple_http_connection_handler<t_connection_context>::handle_invoke_query_line()
 	{ 
-		LOG_FRAME("simple_http_connection_handler<t_connection_context>::handle_recognize_protocol_out(*)", LOG_LEVEL_3);
-
 		STATIC_REGEXP_EXPR_1(rexp_match_command_line, "^(((OPTIONS)|(GET)|(HEAD)|(POST)|(PUT)|(DELETE)|(TRACE)) (\\S+) HTTP/(\\d+).(\\d+))\r?\n", boost::regex::icase | boost::regex::normal);
 		//											    123         4     5      6      7     8        9        10          11     12    
 		//size_t match_len = 0;
@@ -379,8 +380,6 @@ namespace net_utils
 	{ 
 		//LOG_PRINT_L4("HTTP HEAD:\r\n" << m_cache.substr(0, pos));
 
-		LOG_FRAME("simple_http_connection_handler<t_connection_context>::analize_cached_request_header_and_invoke_state(*)", LOG_LEVEL_3);
-
 		m_query_info.m_full_request_buf_size = pos;
     m_query_info.m_request_head.assign(m_cache.begin(), m_cache.begin()+pos); 
 
@@ -479,8 +478,6 @@ namespace net_utils
   template<class t_connection_context>
 	bool simple_http_connection_handler<t_connection_context>::parse_cached_header(http_header_info& body_info, const std::string& m_cache_to_process, size_t pos)
 	{ 
-		LOG_FRAME("http_stream_filter::parse_cached_header(*)", LOG_LEVEL_3);
-
 		STATIC_REGEXP_EXPR_1(rexp_mach_field, 
 			"\n?((Connection)|(Referer)|(Content-Length)|(Content-Type)|(Transfer-Encoding)|(Content-Encoding)|(Host)|(Cookie)|(User-Agent)"
 			//  12            3         4                5              6                   7                  8      9        10
@@ -576,7 +573,7 @@ namespace net_utils
 		m_config.m_lock.unlock();
 		if(!file_io_utils::load_file_to_string(destination_file_path.c_str(), response.m_body))
 		{
-			LOG_PRINT("URI \""<< query_info.m_full_request_str.substr(0, query_info.m_full_request_str.size()-2) << "\" [" << destination_file_path << "] Not Found (404 )" , LOG_LEVEL_1);
+			MWARNING("URI \""<< query_info.m_full_request_str.substr(0, query_info.m_full_request_str.size()-2) << "\" [" << destination_file_path << "] Not Found (404 )");
 			response.m_body = get_not_found_response_body(query_info.m_URI);
 			response.m_response_code = 404;
 			response.m_response_comment = "Not found";
@@ -584,7 +581,7 @@ namespace net_utils
 			return true;
 		}
 
-		LOG_PRINT(" -->> " << query_info.m_full_request_str << "\r\n<<--OK" , LOG_LEVEL_3);
+		MDEBUG(" -->> " << query_info.m_full_request_str << "\r\n<<--OK");
 		response.m_response_code = 200;
 		response.m_response_comment = "OK";
 		response.m_mime_tipe = get_file_mime_tipe(uri_to_path);

contrib/epee/include/net/http_server_cp.h

@@ -32,6 +32,10 @@
 
 #include "abstract_tcp_server_cp.h"
 #include "http_server.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_server_cp2.h

@@ -32,6 +32,10 @@
 
 #include "abstract_tcp_server2.h"
 #include "http_protocol_handler.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 namespace net_utils

contrib/epee/include/net/http_server_handlers_map2.h

@@ -31,6 +31,9 @@
 #include "storages/portable_storage.h"
 #include "storages/portable_storage_template_helper.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 
 #define CHAIN_HTTP_TO_MAP2(context_type) bool handle_http_request(const epee::net_utils::http::http_request_info& query_info, \
               epee::net_utils::http::http_response_info& response, \
@@ -77,7 +80,7 @@
       uint64_t ticks3 = epee::misc_utils::get_tick_count(); \
       response_info.m_mime_tipe = "application/json"; \
       response_info.m_header_info.m_content_type = " application/json"; \
-      LOG_PRINT( s_pattern << " processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms", LOG_LEVEL_2); \
+      MDEBUG( s_pattern << " processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms"); \
     }
 
 #define MAP_URI_AUTO_JON2(s_pattern, callback_f, command_type) MAP_URI_AUTO_JON2_IF(s_pattern, callback_f, command_type, true)
@@ -104,7 +107,7 @@
       uint64_t ticks3 = epee::misc_utils::get_tick_count(); \
       response_info.m_mime_tipe = " application/octet-stream"; \
       response_info.m_header_info.m_content_type = " application/octet-stream"; \
-      LOG_PRINT( s_pattern << "() processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms", LOG_LEVEL_2); \
+      MDEBUG( s_pattern << "() processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms"); \
     }
 
 #define CHAIN_URI_MAP2(callback) else {callback(query_info, response_info, m_conn_context);handled = true;}
@@ -166,7 +169,7 @@
   uint64_t ticks3 = epee::misc_utils::get_tick_count(); \
   response_info.m_mime_tipe = "application/json"; \
   response_info.m_header_info.m_content_type = " application/json"; \
-  LOG_PRINT( query_info.m_URI << "[" << method_name << "] processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms", LOG_LEVEL_2);
+  MDEBUG( query_info.m_URI << "[" << method_name << "] processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms");
 
 #define MAP_JON_RPC_WE_IF(method_name, callback_f, command_type, cond) \
     else if((callback_name == method_name) && (cond)) \

contrib/epee/include/net/http_server_impl_base.h

@@ -36,6 +36,9 @@
 #include "net/http_server_cp2.h"
 #include "net/http_server_handlers_map2.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
+
 namespace epee
 {
 
@@ -79,15 +82,14 @@ namespace epee
     bool run(size_t threads_count, bool wait = true)
     {
       //go to loop
-      LOG_PRINT("Run net_service loop( " << threads_count << " threads)...", LOG_LEVEL_0);
+      MINFO("Run net_service loop( " << threads_count << " threads)...");
-      _fact_c("net/RPClog", "Run net_service loop( " << threads_count << " threads)...");
       if(!m_net_server.run_server(threads_count, wait))
       {
         LOG_ERROR("Failed to run net tcp server!");
       }
 
       if(wait)
-        LOG_PRINT("net_service loop stopped.", LOG_LEVEL_0);
+        MINFO("net_service loop stopped.");
       return true;
     }
 

contrib/epee/include/net/levin_client.inl

@@ -30,6 +30,10 @@
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------------------
 #include "string_tools.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 namespace epee
 {
 namespace levin

contrib/epee/include/net/levin_client_async.h

@@ -31,6 +31,9 @@
 #include "net_helper.h"
 #include "levin_base.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 
 namespace epee
 {

contrib/epee/include/net/levin_helper.h

@@ -31,6 +31,9 @@
 #include "levin_base.h"
 #include "serializeble_struct_helper.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 namespace epee
 {
 namespace levin

contrib/epee/include/net/levin_protocol_handler.h

@@ -32,6 +32,9 @@
 #include <boost/uuid/uuid_generators.hpp>
 #include "levin_base.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 namespace epee
 {
 namespace levin
@@ -85,7 +88,7 @@ namespace levin
 	{
 		if(!m_config.m_pcommands_handler)
 		{
-			LOG_ERROR("Command handler not set!");
+			LOG_ERROR_CC(m_conn_context, "Command handler not set!");
 			return false;
 		}
 		m_cach_in_buffer.append((const char*)ptr, cb);
@@ -100,7 +103,7 @@ namespace levin
 				{
 					if(m_cach_in_buffer.size() >= sizeof(uint64_t) && *((uint64_t*)m_cach_in_buffer.data()) != LEVIN_SIGNATURE)
 					{
-						LOG_ERROR("Signature missmatch on accepted connection");
+						LOG_ERROR_CC(m_conn_context, "Signature missmatch on accepted connection");
 						return false;
 					}
 					is_continue = false;
@@ -110,7 +113,7 @@ namespace levin
 					bucket_head* phead = (bucket_head*)m_cach_in_buffer.data();
 					if(LEVIN_SIGNATURE != phead->m_signature)
 					{
-						LOG_ERROR("Signature missmatch on accepted connection");
+						LOG_ERROR_CC(m_conn_context, "Signature missmatch on accepted connection");
 						return false;
 					}
 					m_current_head = *phead;
@@ -154,7 +157,7 @@ namespace levin
 				m_state = conn_state_reading_head;
 				break;
 			default:
-				LOG_ERROR("Undefined state in levin_server_impl::connection_handler, m_state=" << m_state);
+				LOG_ERROR_CC(m_conn_context, "Undefined state in levin_server_impl::connection_handler, m_state=" << m_state);
 				return false;
 			}
 		}

contrib/epee/include/net/levin_protocol_handler_async.h

@@ -38,6 +38,8 @@
 #include <random>
 #include <chrono>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
 
 namespace epee
 {
@@ -151,7 +153,7 @@ public:
         {
           if(ec == boost::asio::error::operation_aborted)
             return;
-          LOG_PRINT_CC(con.get_context_ref(), "Timeout on invoke operation happened, command: " << command, LOG_LEVEL_2);
+          MINFO(con.get_context_ref() << "Timeout on invoke operation happened, command: " << command);
           std::string fake;
           cb(LEVIN_ERROR_CONNECTION_TIMEDOUT, fake, con.get_context_ref());
           con.close();
@@ -244,15 +246,15 @@ public:
     }
     CHECK_AND_ASSERT_MES_NO_RET(0 == boost::interprocess::ipcdetail::atomic_read32(&m_wait_count), "Failed to wait for operation completion. m_wait_count = " << m_wait_count);
 
-    LOG_PRINT_CC(m_connection_context, "~async_protocol_handler()", LOG_LEVEL_4);
+    MTRACE(m_connection_context << "~async_protocol_handler()");
   }
 
   bool start_outer_call()
   {
-    LOG_PRINT_CC_L4(m_connection_context, "[levin_protocol] -->> start_outer_call");
+    MTRACE(m_connection_context << "[levin_protocol] -->> start_outer_call");
     if(!m_pservice_endpoint->add_ref())
     {
-      LOG_PRINT_CC_RED(m_connection_context, "[levin_protocol] -->> start_outer_call failed", LOG_LEVEL_4);
+      MERROR(m_connection_context << "[levin_protocol] -->> start_outer_call failed");
       return false;
     }
     boost::interprocess::ipcdetail::atomic_inc32(&m_wait_count);
@@ -260,7 +262,7 @@ public:
   }
   bool finish_outer_call()
   {
-    LOG_PRINT_CC_L4(m_connection_context, "[levin_protocol] <<-- finish_outer_call");
+    MTRACE(m_connection_context << "[levin_protocol] <<-- finish_outer_call");
     boost::interprocess::ipcdetail::atomic_dec32(&m_wait_count);
     m_pservice_endpoint->release();
     return true;
@@ -316,13 +318,13 @@ public:
 
     if(!m_config.m_pcommands_handler)
     {
-      LOG_ERROR_CC(m_connection_context, "Commands handler not set!");
+      MERROR(m_connection_context << "Commands handler not set!");
       return false;
     }
 
     if(m_cache_in_buffer.size() +  cb > m_config.m_max_packet_size)
     {
-      LOG_ERROR_CC(m_connection_context, "Maximum packet size exceed!, m_max_packet_size = " << m_config.m_max_packet_size 
+      MWARNING(m_connection_context << "Maximum packet size exceed!, m_max_packet_size = " << m_config.m_max_packet_size
                           << ", packet received " << m_cache_in_buffer.size() +  cb 
                           << ", connection will be closed.");
       return false;
@@ -353,7 +355,7 @@ public:
 
           bool is_response = (m_oponent_protocol_ver == LEVIN_PROTOCOL_VER_1 && m_current_head.m_flags&LEVIN_PACKET_RESPONSE);
 
-          LOG_PRINT_CC_L4(m_connection_context, "LEVIN_PACKET_RECIEVED. [len=" << m_current_head.m_cb 
+          MDEBUG(m_connection_context << "LEVIN_PACKET_RECIEVED. [len=" << m_current_head.m_cb
             << ", flags" << m_current_head.m_flags 
             << ", r?=" << m_current_head.m_have_to_return_data 
             <<", cmd = " << m_current_head.m_command 
@@ -381,7 +383,7 @@ public:
               //use sync call scenario
               if(!boost::interprocess::ipcdetail::atomic_read32(&m_wait_count) && !boost::interprocess::ipcdetail::atomic_read32(&m_close_called))
               {
-                LOG_ERROR_CC(m_connection_context, "no active invoke when response came, wtf?");
+                MERROR(m_connection_context << "no active invoke when response came, wtf?");
                 return false;
               }else
               {
@@ -413,7 +415,7 @@ public:
               if(!m_pservice_endpoint->do_send(send_buff.data(), send_buff.size()))
                 return false;
               CRITICAL_REGION_END();
-              LOG_PRINT_CC_L4(m_connection_context, "LEVIN_PACKET_SENT. [len=" << m_current_head.m_cb 
+              MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << m_current_head.m_cb
                 << ", flags" << m_current_head.m_flags 
                 << ", r?=" << m_current_head.m_have_to_return_data 
                 <<", cmd = " << m_current_head.m_command 
@@ -431,7 +433,7 @@ public:
           {
             if(m_cache_in_buffer.size() >= sizeof(uint64_t) && *((uint64_t*)m_cache_in_buffer.data()) != LEVIN_SIGNATURE)
             {
-              LOG_ERROR_CC(m_connection_context, "Signature mismatch, connection will be closed");
+              MWARNING(m_connection_context << "Signature mismatch, connection will be closed");
               return false;
             }
             is_continue = false;
@@ -585,7 +587,7 @@ public:
     }
     CRITICAL_REGION_END();
 
-    LOG_PRINT_CC_L4(m_connection_context, "LEVIN_PACKET_SENT. [len=" << head.m_cb 
+    MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << head.m_cb
                             << ", f=" << head.m_flags 
                             << ", r?=" << head.m_have_to_return_data 
                             << ", cmd = " << head.m_command 
@@ -597,7 +599,7 @@ public:
     {
       if(misc_utils::get_tick_count() - ticks_start > m_config.m_invoke_timeout)
       {
-        LOG_PRINT_CC_L2(m_connection_context, "invoke timeout (" << m_config.m_invoke_timeout << "), closing connection ");
+        MWARNING(m_connection_context << "invoke timeout (" << m_config.m_invoke_timeout << "), closing connection ");
         close();
         return LEVIN_ERROR_CONNECTION_TIMEDOUT;
       }
@@ -650,7 +652,7 @@ public:
       return -1;
     }
     CRITICAL_REGION_END();
-    LOG_PRINT_CC_L4(m_connection_context, "LEVIN_PACKET_SENT. [len=" << head.m_cb << 
+    LOG_DEBUG_CC(m_connection_context, "LEVIN_PACKET_SENT. [len=" << head.m_cb <<
       ", f=" << head.m_flags << 
       ", r?=" << head.m_have_to_return_data <<
       ", cmd = " << head.m_command << 

contrib/epee/include/net/net_helper.h

@@ -46,6 +46,9 @@
 //#include "profile_tools.h"
 #include "../string_tools.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 #ifndef MAKE_IP
 #define MAKE_IP( a1, a2, a3, a4 )	(a1|(a2<<8)|(a3<<16)|(a4<<24))
 #endif
@@ -180,19 +183,19 @@ namespace net_utils
 					return true;
 				}else
 				{
-					LOG_PRINT("Some problems at connect, message: " << ec.message(), LOG_LEVEL_3);
+					MWARNING("Some problems at connect, message: " << ec.message());
 					return false;
 				}
 
 			}
 			catch(const boost::system::system_error& er)
 			{
-				LOG_PRINT("Some problems at connect, message: " << er.what(), LOG_LEVEL_4);
+				MDEBUG("Some problems at connect, message: " << er.what());
 				return false;
 			}
 			catch(...)
 			{
-				LOG_PRINT("Some fatal problems.", LOG_LEVEL_4);
+				MDEBUG("Some fatal problems.");
 				return false;
 			}
 
@@ -387,20 +390,20 @@ namespace net_utils
 
 				if (ec)
 				{
-                    LOG_PRINT_L4("READ ENDS: Connection err_code " << ec.value());
+                    MTRACE("READ ENDS: Connection err_code " << ec.value());
                     if(ec == boost::asio::error::eof)
                     {
-                      LOG_PRINT_L4("Connection err_code eof.");
+                      MTRACE("Connection err_code eof.");
                       //connection closed there, empty
                       return true;
                     }
 
-					LOG_PRINT_L3("Problems at read: " << ec.message());
+					MDEBUG("Problems at read: " << ec.message());
                     m_connected = false;
 					return false;
 				}else
 				{
-                    LOG_PRINT_L4("READ ENDS: Success. bytes_tr: " << bytes_transfered);
+                    MTRACE("READ ENDS: Success. bytes_tr: " << bytes_transfered);
 					m_deadline.expires_at(boost::posix_time::pos_infin);
 				}
 

contrib/epee/include/net/net_parse_helpers.h

@@ -31,6 +31,8 @@
 #include "http_base.h"
 #include "reg_exp_definer.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
 
 namespace epee
 {

contrib/epee/include/net/net_utils_base.h

@@ -31,6 +31,10 @@
 
 #include <boost/uuid/uuid.hpp>
 #include "string_tools.h"
+#include "misc_log_ex.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
 
 #ifndef MAKE_IP
 #define MAKE_IP( a1, a2, a3, a4 )	(a1|(a2<<8)|(a3<<16)|(a4<<24))
@@ -142,20 +146,24 @@ namespace net_utils
     return ss.str();
   }
 
-#define LOG_PRINT_CC(ct, message, log_level) LOG_PRINT("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
+inline MAKE_LOGGABLE(connection_context_base, ct, os)
-#define LOG_PRINT_CC_GREEN(ct, message, log_level) LOG_PRINT_GREEN("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
+{
-#define LOG_PRINT_CC_RED(ct, message, log_level) LOG_PRINT_RED("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
+  os << "[" << epee::net_utils::print_connection_context_short(ct) << "] ";
-#define LOG_PRINT_CC_BLUE(ct, message, log_level) LOG_PRINT_BLUE("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
+  return os;
-#define LOG_PRINT_CC_YELLOW(ct, message, log_level) LOG_PRINT_YELLOW("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
+}
-#define LOG_PRINT_CC_CYAN(ct, message, log_level) LOG_PRINT_CYAN("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
-#define LOG_PRINT_CC_MAGENTA(ct, message, log_level) LOG_PRINT_MAGENTA("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
-#define LOG_ERROR_CC(ct, message) LOG_PRINT_RED("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, LOG_LEVEL_2)
 
-#define LOG_PRINT_CC_L0(ct, message) LOG_PRINT_L0("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)
+#define LOG_ERROR_CC(ct, message) MERROR(ct << message)
-#define LOG_PRINT_CC_L1(ct, message) LOG_PRINT_L1("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)
+#define LOG_WARNING_CC(ct, message) MWARNING(ct << message)
-#define LOG_PRINT_CC_L2(ct, message) LOG_PRINT_L2("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)
+#define LOG_INFO_CC(ct, message) MINFO(ct << message)
-#define LOG_PRINT_CC_L3(ct, message) LOG_PRINT_L3("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)
+#define LOG_DEBUG_CC(ct, message) MDEBUG(ct << message)
-#define LOG_PRINT_CC_L4(ct, message) LOG_PRINT_L4("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)
+#define LOG_TRACE_CC(ct, message) MTRACE(ct << message)
+#define LOG_CC(level, ct, message) MLOG(level, ct << message)
+
+#define LOG_PRINT_CC_L0(ct, message) LOG_PRINT_L0(epee::net_utils::print_connection_context_short(ct) << message)
+#define LOG_PRINT_CC_L1(ct, message) LOG_PRINT_L1(epee::net_utils::print_connection_context_short(ct) << message)
+#define LOG_PRINT_CC_L2(ct, message) LOG_PRINT_L2(epee::net_utils::print_connection_context_short(ct) << message)
+#define LOG_PRINT_CC_L3(ct, message) LOG_PRINT_L3(epee::net_utils::print_connection_context_short(ct) << message)
+#define LOG_PRINT_CC_L4(ct, message) LOG_PRINT_L4(epee::net_utils::print_connection_context_short(ct) << message)
 
 #define LOG_PRINT_CCONTEXT_L0(message) LOG_PRINT_CC_L0(context, message)
 #define LOG_PRINT_CCONTEXT_L1(message) LOG_PRINT_CC_L1(context, message)
@@ -163,13 +171,6 @@ namespace net_utils
 #define LOG_PRINT_CCONTEXT_L3(message) LOG_PRINT_CC_L3(context, message)
 #define LOG_ERROR_CCONTEXT(message)    LOG_ERROR_CC(context, message)
  
-#define LOG_PRINT_CCONTEXT_GREEN(message, log_level) LOG_PRINT_CC_GREEN(context, message, log_level)
-#define LOG_PRINT_CCONTEXT_RED(message, log_level) LOG_PRINT_CC_RED(context, message, log_level)
-#define LOG_PRINT_CCONTEXT_BLUE(message, log_level) LOG_PRINT_CC_BLUE(context, message, log_level) 
-#define LOG_PRINT_CCONTEXT_YELLOW(message, log_level) LOG_PRINT_CC_YELLOW(context, message, log_level) 
-#define LOG_PRINT_CCONTEXT_CYAN(message, log_level) LOG_PRINT_CC_CYAN(context, message, log_level) 
-#define LOG_PRINT_CCONTEXT_MAGENTA(message, log_level) LOG_PRINT_CC_MAGENTA(context, message, log_level) 
-
 #define CHECK_AND_ASSERT_MES_CC(condition, return_val, err_message) CHECK_AND_ASSERT_MES(condition, return_val, "[" << epee::net_utils::print_connection_context_short(context) << "]" << err_message)
 
 }

contrib/epee/include/profile_tools.h

@@ -52,8 +52,8 @@ namespace epee
 #endif
 
 #define START_WAY_POINTS() uint64_t _____way_point_time = epee::misc_utils::get_tick_count();
-#define WAY_POINT(name) {uint64_t delta = epee::misc_utils::get_tick_count()-_____way_point_time; LOG_PRINT("Way point " << name << ": " << delta, LOG_LEVEL_2);_____way_point_time = misc_utils::get_tick_count();}
+#define WAY_POINT(name) {uint64_t delta = epee::misc_utils::get_tick_count()-_____way_point_time; MDEBUG("Way point " << name << ": " << delta);_____way_point_time = misc_utils::get_tick_count();}
-#define WAY_POINT2(name, avrg_obj) {uint64_t delta = epee::misc_utils::get_tick_count()-_____way_point_time; avrg_obj.push(delta); LOG_PRINT("Way point " << name << ": " << delta, LOG_LEVEL_2);_____way_point_time = misc_utils::get_tick_count();}
+#define WAY_POINT2(name, avrg_obj) {uint64_t delta = epee::misc_utils::get_tick_count()-_____way_point_time; avrg_obj.push(delta); MDEBUG("Way point " << name << ": " << delta);_____way_point_time = misc_utils::get_tick_count();}
 
 
 #define TIME_MEASURE_START(var_name)    uint64_t var_name = epee::misc_utils::get_tick_count();
@@ -67,7 +67,7 @@ namespace profile_tools
 		{}
 		~local_call_account()
 		{
-			LOG_PRINT2("profile_details.log", "PROFILE "<<m_pname<<":av_time:\t" << (m_count_of_call ? (m_summary_time_used/m_count_of_call):0) <<" sum_time:\t"<<m_summary_time_used<<" call_count:\t" << m_count_of_call, LOG_LEVEL_0);
+			MINFO("PROFILE "<<m_pname<<":av_time:\t" << (m_count_of_call ? (m_summary_time_used/m_count_of_call):0) <<" sum_time:\t"<<m_summary_time_used<<" call_count:\t" << m_count_of_call);
 		}
 
 		size_t m_count_of_call;

contrib/epee/include/storages/levin_abstract_invoke2.h

@@ -30,6 +30,9 @@
 #include <boost/utility/value_init.hpp>
 #include "net/levin_base.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net"
+
 namespace epee
 {
   namespace net_utils
@@ -48,7 +51,7 @@ namespace epee
       int res = transport.invoke(command, buff_to_send, buff_to_recv);
       if( res <=0 )
       {
-        LOG_PRINT_RED("Failed to invoke command " << command << " return code " << res, LOG_LEVEL_1);
+        MERROR("Failed to invoke command " << command << " return code " << res);
         return false;
       }
       serialization::portable_storage stg_ret;
@@ -154,7 +157,7 @@ namespace epee
       int res = transport.notify(command, buff_to_send, conn_id);
       if(res <=0 )
       {
-        LOG_PRINT_RED_L0("Failed to notify command " << command << " return code " << res);
+        MERROR("Failed to notify command " << command << " return code " << res);
         return false;
       }
       return true;

contrib/epee/include/storages/portable_storage_from_json.h

@@ -365,12 +365,12 @@ namespace epee
         }
         catch(const std::exception& ex)
         {
-          LOG_PRINT_RED_L0("Failed to parse json, what: " << ex.what());
+          MERROR("Failed to parse json, what: " << ex.what());
           return false;
         }
         catch(...)
         {
-          LOG_PRINT_RED_L0("Failed to parse json");
+          MERROR("Failed to parse json");
           return false;
         }
       }

contrib/epee/src/CMakeLists.txt

@@ -26,4 +26,4 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-add_library(epee STATIC http_auth.cpp)
+add_library(epee STATIC http_auth.cpp mlog.cpp)

contrib/epee/src/mlog.cpp

@@ -0,0 +1,319 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+
+
+#ifndef _MLOG_H_
+#define _MLOG_H_
+
+#include <atomic>
+#include "misc_log_ex.h"
+
+INITIALIZE_EASYLOGGINGPP
+
+//#define MLOG_BASE_FORMAT "%datetime{%Y-%M-%d %H:%m:%s.%g}\t%thread\t%level\t%logger\t%fbase:%line\t%msg"
+#define MLOG_BASE_FORMAT "%datetime{%Y-%M-%d %H:%m:%s.%g}\t%thread\t%level\t%logger\t%loc\t%msg"
+
+using namespace epee;
+
+static std::string generate_log_filename(const char *base)
+{
+  std::string filename(base);
+  char tmp[200];
+  struct tm tm;
+  time_t now = time(NULL);
+  if (!gmtime_r(&now, &tm))
+    strcpy(tmp, "unknown");
+  else
+    strftime(tmp, sizeof(tmp), "%Y-%m-%d-%H-%M-%S", &tm);
+  filename += "-";
+  filename += tmp;
+  return filename;
+}
+
+std::string mlog_get_default_log_path(const char *default_filename)
+{
+  std::string process_name = epee::string_tools::get_current_module_name();
+  std::string default_log_folder = epee::string_tools::get_current_module_folder();
+  std::string default_log_file = process_name;
+  std::string::size_type a = default_log_file.rfind('.');
+  if ( a != std::string::npos )
+    default_log_file.erase( a, default_log_file.size());
+  if ( ! default_log_file.empty() )
+    default_log_file += ".log";
+  else
+    default_log_file = default_filename;
+
+  return (boost::filesystem::path(default_log_folder) / boost::filesystem::path(default_log_file)).string();
+}
+
+static void mlog_set_common_prefix()
+{
+  static const char * const expected_filename = "contrib/epee/src/mlog.cpp";
+  const char *path = __FILE__, *expected_ptr = strstr(path, expected_filename);
+  if (!expected_ptr)
+    return;
+  el::Loggers::setFilenameCommonPrefix(std::string(path, expected_ptr - path));
+}
+
+void mlog_configure(const std::string &filename_base, bool console)
+{
+  el::Configurations c;
+  c.setGlobally(el::ConfigurationType::Filename, filename_base);
+  c.setGlobally(el::ConfigurationType::ToFile, "true");
+  c.setGlobally(el::ConfigurationType::Format, MLOG_BASE_FORMAT);
+  c.setGlobally(el::ConfigurationType::ToStandardOutput, console ? "true" : "false");
+  c.setGlobally(el::ConfigurationType::MaxLogFileSize, "104850000"); // 100 MB - 7600 bytes
+  el::Loggers::setDefaultConfigurations(c, true);
+
+  el::Loggers::addFlag(el::LoggingFlag::HierarchicalLogging);
+  el::Loggers::addFlag(el::LoggingFlag::CreateLoggerAutomatically);
+  el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
+  el::Loggers::addFlag(el::LoggingFlag::ColoredTerminalOutput);
+  el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck);
+  el::Helpers::installPreRollOutCallback([&filename_base](const char *name, size_t){
+    std::string rname = generate_log_filename(filename_base.c_str());
+    rename(name, rname.c_str());
+  });
+  mlog_set_common_prefix();
+  const char *monero_log = getenv("MONERO_LOGS");
+  if (!monero_log)
+  {
+    monero_log = "*:WARNING,net*:FATAL,global:INFO,verify:FATAL";
+  }
+  mlog_set_categories(monero_log);
+}
+
+void mlog_set_categories(const char *categories)
+{
+  el::Loggers::setCategories(categories);
+  MINFO("Mew log categories: " << categories);
+}
+
+// maps epee style log level to new logging system
+void mlog_set_log_level(int level)
+{
+    const char *settings = NULL;
+    switch (level)
+    {
+      case 0:
+        settings = "*:FATAL,net*:FATAL,global:INFO,verify:FATAL";
+        break;
+      case 1:
+        settings = "*:WARNING,global:INFO";
+        break;
+      case 2:
+        settings = "*:INFO";
+        break;
+      case 3:
+        settings = "*:DEBUG";
+        break;
+      case 4:
+        settings = "*:TRACE";
+        break;
+      default:
+        return;
+    }
+
+    el::Loggers::setCategories(settings);
+    MINFO("Mew log categories: " << settings);
+}
+
+void mlog_set_log(const char *log)
+{
+  long level;
+  char *ptr = NULL;
+
+  level = strtoll(log, &ptr, 10);
+  if (ptr && *ptr)
+  {
+    mlog_set_categories(log);
+  }
+  else if (level >= 0 && level <= 4)
+  {
+    mlog_set_log_level(level);
+  }
+  else
+  {
+    MERROR("Invalid numerical log level: " << log);
+  }
+}
+
+namespace epee
+{
+
+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);
+}
+
+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;
+
+  }
+}
+
+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
+}
+
+}
+
+#endif //_MLOG_H_

contrib/otshell_utils/CMakeLists.txt

@@ -1,18 +0,0 @@
-cmake_minimum_required (VERSION 2.6)
-project (otshell CXX)
-
-# Add executable
-
-if(APPLE AND POLICY CMP0042)
-	cmake_policy(SET CMP0042 NEW)
-endif()
-
-file(GLOB otshell_utils_sources # All files in directory:
-	"*.h"
-	"*.hpp"
-	"*.cpp"
-)
-
-add_library (otshell_utils ${otshell_utils_sources})
-set_target_properties (otshell_utils PROPERTIES OUTPUT_NAME "otshell_utils")
-#target_link_libraries (upnpc-static ${LDLIBS}) # to add used libs

contrib/otshell_utils/LICENCE.txt

@@ -1,21 +0,0 @@
-
-This are some files also from OpenTransactions / otshell project,
-developed thanks to the awesome OpenTransaction project, organization and developers :)
-
-Parts of code here was also developed thanks to the excellent Monero project,
-thanks to Monero project, organization and developers :)
-
-[Some] files/code here (in external/otshell_utils) are under licence defined in
-src/doc/LICENCE-otshell.txt ;
-Others are from monero, with licence in src/doc/LICENCE-monero.txt ;
-
-For me (rfree) the licence seem compatbile so no problem, personally (as author of many parts of the code,
-possibly not all) I do not worry who uses it how; I'am not a lawyer.
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Please share :-) This licence can be used e.g. for parts of code that are usable in both open-source FOSS project
-Monero and Open Transactions, to share and develop both faster.
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-
-

contrib/otshell_utils/ccolor.cpp

@@ -1,116 +0,0 @@
-#include "ccolor.hpp"
-#include <cstdarg>
-
-// from http://stackoverflow.com/questions/2616906/how-do-i-output-coloured-text-to-a-linux-terminal
-// from http://wiznet.gr/src/ccolor.zip
-// edited by rfree - as part of https://github.com/rfree/Open-Transactions/
-
-using namespace std;
-
-#ifdef _MSC_VER
-
-#define snprintf c99_snprintf
-
-inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap) {
-	int count = -1;
-	if (size != 0)
-		 count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
-	if (count == -1)
-		 count = _vscprintf(format, ap);
-	return count;
-}
-
-inline int c99_snprintf(char* str, size_t size, const char* format, ...) {
-	int count;
-	va_list ap;
-	va_start(ap, format);
-	count = c99_vsnprintf(str, size, format, ap);
-	va_end(ap);
-	return count;
-}
-#endif // _MSC_VER
-
-#define CC_CONSOLE_COLOR_DEFAULT "\033[0m"
-#define CC_FORECOLOR(C) "\033[" #C "m"
-#define CC_BACKCOLOR(C) "\033[" #C "m"
-#define CC_ATTR(A) "\033[" #A "m"
-
-namespace zkr
-{
-	enum Color
-	{
-		Black,
-		Red,
-		Green,
-		Yellow,
-		Blue,
-		Magenta,
-		Cyan,
-		White,
-		Default = 9
-	};
-
-	enum Attributes
-	{
-		Reset,
-		Bright,
-		Dim,
-		Underline,
-		Blink,
-		Reverse,
-		Hidden
-	};
-
-	char * cc::color(int attr, int fg, int bg)
-	{
-				static const int size = 20;
-        static char command[size];
-
-        /* Command is the control command to the terminal */
-        snprintf(command, size, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
-        return command;
-	}
-
-
-	const char *cc::console = CC_CONSOLE_COLOR_DEFAULT;
-	const char *cc::underline = CC_ATTR(4);
-	const char *cc::bold = CC_ATTR(1);
-
-	const char *cc::fore::black = CC_FORECOLOR(30);
-	const char *cc::fore::blue = CC_FORECOLOR(34);
-	const char *cc::fore::red = CC_FORECOLOR(31);
-	const char *cc::fore::magenta = CC_FORECOLOR(35);
-	const char *cc::fore::green = CC_FORECOLOR(92);
-	const char *cc::fore::cyan = CC_FORECOLOR(36);
-	const char *cc::fore::yellow = CC_FORECOLOR(33);
-	const char *cc::fore::white = CC_FORECOLOR(37);
-	const char *cc::fore::console = CC_FORECOLOR(39);
-
-	const char *cc::fore::lightblack = CC_FORECOLOR(90);
-	const char *cc::fore::lightblue = CC_FORECOLOR(94);
-	const char *cc::fore::lightred = CC_FORECOLOR(91);
-	const char *cc::fore::lightmagenta = CC_FORECOLOR(95);
-	const char *cc::fore::lightgreen = CC_FORECOLOR(92);
-	const char *cc::fore::lightcyan = CC_FORECOLOR(96);
-	const char *cc::fore::lightyellow = CC_FORECOLOR(93);
-	const char *cc::fore::lightwhite = CC_FORECOLOR(97);
-
-	const char *cc::back::black = CC_BACKCOLOR(40);
-	const char *cc::back::blue = CC_BACKCOLOR(44);
-	const char *cc::back::red = CC_BACKCOLOR(41);
-	const char *cc::back::magenta = CC_BACKCOLOR(45);
-	const char *cc::back::green = CC_BACKCOLOR(42);
-	const char *cc::back::cyan = CC_BACKCOLOR(46);
-	const char *cc::back::yellow = CC_BACKCOLOR(43);
-	const char *cc::back::white = CC_BACKCOLOR(47);
-	const char *cc::back::console = CC_BACKCOLOR(49);
-
-	const char *cc::back::lightblack = CC_BACKCOLOR(100);
-	const char *cc::back::lightblue = CC_BACKCOLOR(104);
-	const char *cc::back::lightred = CC_BACKCOLOR(101);
-	const char *cc::back::lightmagenta = CC_BACKCOLOR(105);
-	const char *cc::back::lightgreen = CC_BACKCOLOR(102);
-	const char *cc::back::lightcyan = CC_BACKCOLOR(106);
-	const char *cc::back::lightyellow = CC_BACKCOLOR(103);
-	const char *cc::back::lightwhite = CC_BACKCOLOR(107);
-}

contrib/otshell_utils/ccolor.hpp

@@ -1,73 +0,0 @@
-// ccolor.hpp
-
-// from http://stackoverflow.com/questions/2616906/how-do-i-output-coloured-text-to-a-linux-terminal
-// from http://wiznet.gr/src/ccolor.zip
-// edited by rfree - as part of https://github.com/rfree/Open-Transactions/
-
-#ifndef INCLUDE_OT_ccolor
-#define INCLUDE_OT_ccolor
-
-#include <iostream>
-#include <stdio.h>
-
-namespace zkr
-{
-	class cc
-	{
-	public:
-
-		class fore
-		{
-		public:
-			static const char *black;
-			static const char *blue;
-			static const char *red;
-			static const char *magenta;
-			static const char *green;
-			static const char *cyan;
-			static const char *yellow;
-			static const char *white;
-			static const char *console;
-
-			static const char *lightblack;
-			static const char *lightblue;
-			static const char *lightred;
-			static const char *lightmagenta;
-			static const char *lightgreen;
-			static const char *lightcyan;
-			static const char *lightyellow;
-			static const char *lightwhite;
-		};
-
-		class back
-		{
-		public:
-			static const char *black;
-			static const char *blue;
-			static const char *red;
-			static const char *magenta;
-			static const char *green;
-			static const char *cyan;
-			static const char *yellow;
-			static const char *white;
-			static const char *console;
-
-			static const char *lightblack;
-			static const char *lightblue;
-			static const char *lightred;
-			static const char *lightmagenta;
-			static const char *lightgreen;
-			static const char *lightcyan;
-			static const char *lightyellow;
-			static const char *lightwhite;
-		};
-
-		static char *color(int attr, int fg, int bg);
-		static const char *console;
-		static const char *underline;
-		static const char *bold;
-	};
-}
-
-#endif
-

contrib/otshell_utils/lib_common1.hpp

@@ -1,53 +0,0 @@
-/* See other files here for the LICENCE that applies here. */
-
-
-#ifndef INCLUDE_OT_NEWCLI_COMMON1
-#define INCLUDE_OT_NEWCLI_COMMON1
-
-#include <string>
-#include <cstring>
-#include <vector>
-#include <map>
-#include <list>
-#include <algorithm>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <set>
-#include <iterator>
-#include <stdexcept>
-
-#include <functional>
-#include <memory>
-#include <atomic>
-#include <boost/thread.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/recursive_mutex.hpp>
-#include <boost/thread/lock_guard.hpp>
-
-
-// list of thigs from libraries that we pull into namespace nOT::nNewcli
-// we might still need to copy/paste it in few places to make IDEs pick it up correctly
-#define INJECT_OT_COMMON_USING_NAMESPACE_COMMON_1 \
-	using std::string; \
-	using std::vector; \
-	using std::vector; \
-	using std::list; \
-	using std::set; \
-	using std::map; \
-	using std::ostream; \
-	using std::istream; \
-	using std::cin; \
-	using std::cerr; \
-	using std::cout; \
-	using std::cerr; \
-	using std::endl; \
-	using std::function; \
-	using std::unique_ptr; \
-	using std::shared_ptr; \
-	using std::weak_ptr; \
-	using std::enable_shared_from_this; \
-	using boost::lock_guard; \
-
-#endif
-

contrib/otshell_utils/runoptions.cpp

@@ -1,69 +0,0 @@
-/* See other files here for the LICENCE that applies here. */
-/* See header file .hpp for info */
-
-#include "runoptions.hpp"
-
-#include "lib_common1.hpp"
-
-namespace nOT {
-
-INJECT_OT_COMMON_USING_NAMESPACE_COMMON_1 // <=== namespaces
-
-// (no debug - this is the default)
-// +nodebug (no debug)
-// +debug ...... --asdf
-// +debug +debugcerr .... --asfs
-// +debug +debugfile .... --asfs
-
-cRunOptions::cRunOptions()
-	: mRunMode(eRunModeCurrent), mDebug(false), mDebugSendToFile(false), mDebugSendToCerr(false)
-	,mDoRunDebugshow(false)
-{ }
-
-vector<string> cRunOptions::ExecuteRunoptionsAndRemoveThem(const vector<string> & args) {
-	vector<string> arg_clear; // will store only the arguments that are not removed
-
-	for (auto arg : args) {
-		bool thisIsRunoption=false;
-
-		if (arg.size()>0) {
-			if (arg.at(0) == '+') thisIsRunoption=true;
-		}
-
-		if (thisIsRunoption) Exec(arg); // ***
-		if (! thisIsRunoption) arg_clear.push_back(arg);
-	}
-
-	Normalize();
-
-	return arg_clear;
-}
-
-void cRunOptions::Exec(const string & runoption) { // eg: Exec("+debug");
-	if (runoption == "+nodebug") { mDebug=false; }
-	else if (runoption == "+debug") { mDebug=true; }
-	else if (runoption == "+debugcerr") { mDebug=true;  mDebugSendToCerr=true; }
-	else if (runoption == "+debugfile") { mDebug=true;  mDebugSendToFile=true; }
-	else if (runoption == "+demo") { mRunMode=eRunModeDemo; }
-	else if (runoption == "+normal") { mRunMode=eRunModeNormal; }
-	else if (runoption == "+current") { mRunMode=eRunModeCurrent; }
-	else if (runoption == "+debugshow") { mDebug=true;  mDebugSendToCerr=true;  mDoRunDebugshow=true; }
-	else {
-		cerr << "Unknown runoption in Exec: '" << runoption << "'" << endl;
-		throw std::runtime_error("Unknown runoption");
-	}
-	// cerr<<"debug="<<mDebug<<endl;
-}
-
-void cRunOptions::Normalize() {
-	if (mDebug) {
-		if (!(  mDebugSendToFile || mDebugSendToCerr  ))  mDebugSendToCerr=true; // if debug is on then send to something, e.g. to cerr
-	}
-}
-
-
-cRunOptions gRunOptions; // (extern)
-
-} // namespace OT
-
-

contrib/otshell_utils/runoptions.hpp

@@ -1,58 +0,0 @@
-/* See other files here for the LICENCE that applies here. */
-/*
-Template for new files, replace word "template" and later delete this line here.
-*/
-
-#ifndef INCLUDE_OT_NEWCLI_runoptions_hpp
-#define INCLUDE_OT_NEWCLI_runoptions_hpp
-
-#include "lib_common1.hpp"
-
-namespace nOT {
-
-INJECT_OT_COMMON_USING_NAMESPACE_COMMON_1 // <=== namespaces
-
-/** Global options to run this program main() Eg used for developer's special options like +setdemo +setdebug.
-This is NOT for all the other options that are parsed and executed by program. */
-class cRunOptions {
-	public:
-		enum tRunMode { ///< Type of run mode - is this normal, or demonstration etc.
-			eRunModeCurrent=1, ///< currently developed version
-			eRunModeDemo, ///< best currently available Demo of something nice
-			eRunModeNormal, ///< do the normal things that the program should do
-		};
-
-	private:
-		tRunMode mRunMode; ///< selected run mode
-
-		bool mDebug; // turn debug on, Eg: +debug without it probably nothing will be written to debug (maybe just error etc)
-		bool mDebugSendToFile; // send to file, Eg: for +debugfile ; also turns on debug
-		bool mDebugSendToCerr; // send to cerr, Eg: for +debugcerr ; also turns on debug
-		// if debug is set but not any other DebugSend* then we will default to sending to debugcerr
-
-		bool mDoRunDebugshow;
-
-	public:
-		tRunMode getTRunMode() const { return mRunMode; }
-		bool getDebug() const { return mDebug; }
-		bool getDebugSendToFile() const { return mDebugSendToFile; }
-		bool getDebugSendToCerr() const { return mDebugSendToCerr; }
-		bool getDoRunDebugshow() const { return mDoRunDebugshow; }
-
-		cRunOptions();
-
-		vector<string> ExecuteRunoptionsAndRemoveThem(const vector<string> & args);
-		void Exec(const string & runoption); // eg: Exec("+debug");
-
-		void Normalize();
-};
-
-extern cRunOptions gRunOptions;
-
-
-} // namespace nOT
-
-
-
-#endif
-

contrib/otshell_utils/utils.cpp

@@ -1,806 +0,0 @@
-/// @file
-/// @author rfree (current maintainer in monero.cc project)
-/// @brief various general utils taken from (and relate to) otshell project, including loggiang/debug
-
-/* See other files here for the LICENCE that applies here. */
-/* See header file .hpp for info */
-
-#include <algorithm>
-#include <functional>
-#include <cctype>
-#include <locale>
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <chrono>
-
-#include "utils.hpp"
-
-#include "ccolor.hpp"
-
-#include "lib_common1.hpp"
-
-#include "runoptions.hpp"
-
-#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined (WIN64)
-	#define OS_TYPE_WINDOWS
-#elif defined(__unix__) || defined(__posix) || defined(__linux) || defined(__darwin) || defined(__APPLE__) || defined(__clang__)
-	#define OS_TYPE_POSIX
-#else
-	#warning "Compiler/OS platform is not recognized. Just assuming it will work as POSIX then"
-	#define OS_TYPE_POSIX
-#endif
-
-#if defined(OS_TYPE_WINDOWS)
-	#include <windows.h>
-	#include <process.h>
-#elif defined(OS_TYPE_POSIX)
-	#include <sys/types.h>
-	#include <sys/stat.h>
-	#include <unistd.h>
-#else
-	#error "Compiler/OS platform detection failed - not supported"
-#endif
-
-
-namespace nOT {
-namespace nUtils {
-
-INJECT_OT_COMMON_USING_NAMESPACE_COMMON_1 // <=== namespaces
-
-// ====================================================================
-
-// Numerical values of the debug levels - see hpp
-const int _debug_level_nr_dbg3=20;
-const int _debug_level_nr_dbg2=30;
-const int _debug_level_nr_dbg1=40;
-const int _debug_level_nr_info=50;
-const int _debug_level_nr_note=60;
-const int _debug_level_nr_fact=75;
-const int _debug_level_nr_mark=80;
-const int _debug_level_nr_warn=90;
-const int _debug_level_nr_erro=100;
-
-// ====================================================================
-
-myexception::myexception(const char * what)
-	: std::runtime_error(what)
-{ }
-
-myexception::myexception(const std::string &what)
-	: std::runtime_error(what)
-{ }
-
-void myexception::Report() const {
-	_erro("Error: " << what());
-}
-
-//myexception::~myexception() { }
-
-// ====================================================================
-
-// text trimming
-// http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
-std::string & ltrim(std::string &s) {
-	s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
-	return s;
-}
-
-std::string & rtrim(std::string &s) {
-	s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
-  return s;
-}
-
-std::string & trim(std::string &s) {
-	return ltrim(rtrim(s));
-}
-
-std::string get_current_time() {
-  std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
-  time_t time_now = std::chrono::system_clock::to_time_t(now);
-  std::chrono::high_resolution_clock::duration duration = now.time_since_epoch();
-  int64_t micro = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
-
-  // std::localtime() - This function may not be thread-safe.
-	#ifdef OS_TYPE_WINDOWS
-		struct tm * tm_pointer = std::localtime( &time_now ); // thread-safe on mingw-w64 (thread local variable) and on MSVC btw
-		// http://stackoverflow.com/questions/18551409/localtime-r-support-on-mingw
-		// tm_pointer points to thread-local data, memory is owned/managed by the system/library
-	#else
-		// linux, freebsd, have this
-		struct tm tm_object; // automatic storage duration http://en.cppreference.com/w/cpp/language/storage_duration
-		struct tm * tm_pointer = & tm_object; // just point to our data
-		auto x = localtime_r( &time_now , tm_pointer    ); // modifies our own (this thread) data in tm_object, this is safe http://linux.die.net/man/3/localtime_r
-		if (x != tm_pointer) return "(internal error in get_current_time)"; // redundant check in case of broken implementation of localtime_r
-	#endif
-	// tm_pointer now points to proper time data, and that memory is automatically managed
-	if (!tm_pointer) return "(internal error in get_current_time - NULL)"; // redundant check in case of broken implementation of used library methods
-
-	std::stringstream stream;
-		stream << std::setfill('0')
-		<< std::setw(2) << tm_pointer->tm_year+1900
-		<< '-' << std::setw(2) << tm_pointer->tm_mon+1
-		<< '-' << std::setw(2) << tm_pointer->tm_mday
-		<< ' ' << std::setw(2) << tm_pointer->tm_hour
-		<< ':' << std::setw(2) << tm_pointer->tm_min
-		<< ':' << std::setw(2) << tm_pointer->tm_sec
-		<< '.' << std::setw(6) << (micro%1000000); // 6 because microseconds
-  return stream.str();
-}
-
-cNullstream g_nullstream; // extern a stream that does nothing (eats/discards data)
-
-boost::recursive_mutex gLoggerGuard; // extern
-std::atomic<int> gLoggerGuardDepth; // extern
-
-std::atomic<int> & gLoggerGuardDepth_Get() {
-	// TODO std::once would be nicer here
-
-	static bool once=0;
-
-	if (!once) { // initialize it once
-		once=1;
-		gLoggerGuardDepth=0;	
-	}
-
-	return gLoggerGuardDepth; // global, atomic counter
-}
-
-
-// ====================================================================
-
-namespace nDetail {
-
-const char* DbgShortenCodeFileName(const char *s) {
-	const char *p = s;
-	const char *a = s;
-
-	bool inc=1;
-	while (*p) {
-		++p;
-		if (inc && ('\0' != * p)) { a=p; inc=false; } // point to the current character (if valid) becasue previous one was slash
-		if ((*p)=='/') { a=p; inc=true; } // point at current slash (but set inc to try to point to next character)
-	}
-	return a;
-}
-
-}
-
-// a workaround for MSVC compiler; e.g. see https://bugs.webkit.org/show_bug.cgi?format=multiple&id=125795
-#ifndef _MSC_VER
-template<typename T, typename ...Args>
-std::unique_ptr<T> make_unique( Args&& ...args )
-{
-	return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
-}
-#else
-	using std::make_unique;
-#endif
-// ====================================================================
-
-char cFilesystemUtils::GetDirSeparatorSys() {
-	// TODO nicer os detection?
-	#if defined(OS_TYPE_POSIX)
-		return '/';
-	#elif defined(OS_TYPE_WINDOWS)
-		return '\\';
-	#else
-		#error "Do not know how to compile this for your platform."
-	#endif
-}
-
-char cFilesystemUtils::GetDirSeparatorInter() {
-	return '/';
-}
-
-string cFilesystemUtils::FileInternalToSystem(const std::string &name) {
-	string ret;
-	ret.resize(name.size());
-	std::replace_copy(name.begin(), name.end(), ret.begin(), 
-		GetDirSeparatorInter() , GetDirSeparatorSys());
-	return ret;
-}
-
-string cFilesystemUtils::FileSystemToInternal(const std::string &name) {
-	string ret;
-	ret.reserve(name.size());
-	std::replace_copy(name.begin(), name.end(), ret.begin(), 
-		GetDirSeparatorSys() , GetDirSeparatorInter());
-	return ret;
-}
-
-bool cFilesystemUtils::CreateDirTree(const std::string & dir, bool only_below) {
-	const bool dbg=false;
-	//struct stat st;
-	const char dirchS = cFilesystemUtils::GetDirSeparatorSys();
-	const char dirchI = cFilesystemUtils::GetDirSeparatorInter();
-	std::istringstream iss(dir);
-	string partI; // current par is in internal format (though it should not matter since it doesn't contain any slashes). eg "bar"
-	string sofarS=""; // sofarS - the so far created dir part is in SYSTEM format. eg "foo/bar"
-	if (dir.size()<1) return false; // illegal name
-	// dir[0] is valid from here
-	if  ( only_below  &&  ((dir[0]==dirchS) || (dir[0]==dirchI))) return false; // no jumping to top (on any os)
-
-	while (getline(iss,partI,dirchI)) { // get new component eg "bar" into part
-		if (dbg) cout << '['<<partI<<']' << endl;
-		sofarS += partI;
-		if (partI.size()<1) return false; // bad format?
-		if ((only_below) && (partI=="..")) return false; // trying to go up
-
-		if (dbg) cout << "test ["<<sofarS<<"]"<<endl;
-		// TODO nicer os detection?
-		#if defined(OS_TYPE_POSIX)
-			struct stat st;
-			bool exists = stat(sofarS.c_str() ,&st) == 0; // *
-			if (exists) {
-				if (! S_ISDIR(st.st_mode)) {
-					// std::cerr << "This exists, but as a file: [" << sofar << "]" << (size_t)st.st_ino << endl;
-					return false; // exists but is a file nor dir
-				}
-			}
-		#elif defined(OS_TYPE_WINDOWS)
-			DWORD dwAttrib = GetFileAttributesA(sofarS.c_str());
-			bool exists = (dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
-		#else
-			#error "Do not know how to compile this for your platform."
-		#endif
-
-		if (!exists) {
-			if (dbg) cout << "mkdir ["<<sofarS<<"]"<<endl;
-			#if defined(OS_TYPE_POSIX)
-				bool ok = 0==  mkdir(sofarS.c_str(), 0700); // ***
-			#elif defined(OS_TYPE_WINDOWS)
-				bool ok = (bool) CreateDirectoryA(sofarS.c_str(), NULL); // TODO use -W() after conversion to unicode UTF16
-			#else
-				#error "Do not know how to compile this for your platform."
-			#endif
-			if (!ok) return false;
-		}
-		sofarS += dirchS;
-	}
-	return true;
-}
-// ====================================================================
-
-namespace nDetail {
-
-struct channel_use_info { ///< feedback information about using (e.g. opening) given debug channel - used internally by logging system 
-/// TODO not yet used in code
-/// e.g. used to write into channel net/in/all that given message was a first logged message from never-before-logged thread or PID etc
-	bool m_was_interesting; ///< anything interesting happened when using the channel?
-	std::vector<std::string> m_extra_msg; ///< any additional messages about this channel use
-};	
-
-cDebugScopeGuard::cDebugScopeGuard() : mLevel(-1) {
-}
-	
-cDebugScopeGuard::~cDebugScopeGuard() {
-	if (mLevel != -1) {
-		gCurrentLogger.write_stream(mLevel,mChan) << mMsg << " ... end" << gCurrentLogger.endline() << std::flush;
-	}
-}
-
-void cDebugScopeGuard::Assign(const string &chan, const int level, const string &msg) {
-	mChan=chan;
-	mLevel=level;
-	mMsg=msg;
-}
-
-} // namespace nDetail
-
-// ====================================================================
-
-cLogger::cLogger() :
-mStream(NULL),
-mStreamBrokenDebug(NULL),
-mIsBroken(true), // before constructor finishes
-mLevel(_debug_level_nr_warn),
-mThread2Number_Biggest(0), // the CURRENT biggest value (no thread yet in map)
-mPid2Number_Biggest(0)
-{
-	mStream = & std::cout;
-	mStreamBrokenDebug = & std::cerr; // the backup stream
-	*mStreamBrokenDebug << "Creating the logger system" << endl;
-	mIsBroken=false; // ok, constr. succeeded, so string is not broken now
-
-	// this is here, because it could be using logging itself to log creation of first thread/PID etc
-	Thread2Number( boost::this_thread::get_id() ); // convert current id to short number, useful to reserve a number so that main thread is usually called 1
-	Pid2Number( getpid() ); // add this proces ID as first one
-}
-
-cLogger::~cLogger() {
-	for (auto pair : mChannels) {
-		std::ofstream *ptr = pair.second;
-		delete ptr;
-		pair.second=NULL;
-	}
-}
-
-void cLogger::SetStreamBroken() {
-	SetStreamBroken("(no additional details about this problem)");
-}
-
-void cLogger::SetStreamBroken(const std::string &msg) {
-	_dbg_dbg("Stream is broken (msg: " << msg << ")");
-	if (!mIsBroken) { // if not already marked as broken
-		_dbg_dbg("(It was not broken before)");
-		std::cerr << OT_CODE_STAMP << "WARNING: due to a problem in the debug/logging system itself ("<<msg<<") - we are switching back to fallback stream (e.g. cerr)" << std::endl;
-		if (mStreamBrokenDebug == nullptr) {
-			std::cerr << OT_CODE_STAMP << " ERROR: in addition, while reporting this problem, mStreamBrokenDebug stream is NULL: " << mStreamBrokenDebug << std::endl;
-		} else {
-			(*mStreamBrokenDebug) << OT_CODE_STAMP << "WARNING: due to debug stream problem ("<<msg<<") - switching back to fallback stream (e.g. cerr)" << std::endl;
-		}
-		mIsBroken = true;
-	}
-}
-
-std::ostream & cLogger::write_stream(int level) {
-	return write_stream(level,"");
-}
-
-std::ostream & cLogger::write_stream(int level, const std::string & channel ) {
-	_dbg_dbg("level="<<level<<" channel="<<channel);
-	if (level >= mLevel) {
-		if (mStream) { // TODO now disabling mStream also disables writting to any channel
-			_dbg_dbg("Selecting output...");
-			ostream & output = SelectOutput(level,channel);
-			_dbg_dbg("Selecting output... done, output=" << (void*)(&output));
-			#if defined(OS_TYPE_WINDOWS)
-			output << windows_stream(level);
-			#endif
-			output << icon(level) << ' ';
-			boost::thread::id this_id = boost::this_thread::get_id();
-			output << "{" << Thread2Number(this_id) << "}";
-			auto nicePid = Pid2Number(getpid());
-			if (nicePid>0) output << " {p" << nicePid << "}";
-			output << ' ';
-			return output; // <--- return
-		} else _dbg_dbg("Not writting: No mStream");
-	} else _dbg_dbg("Not writting: Too low level level="<<level<<" not >= mLevel="<<mLevel);
-	return g_nullstream;
-}
-
-std::string cLogger::GetLogBaseDir() const {
-	return "log";
-}
-
-void cLogger::OpenNewChannel(const std::string & channel) noexcept {
-	try {
-		_dbg_dbg("Openning channel for channel="<<channel);
-		OpenNewChannel_(channel);
-	}
-	catch (const std::exception &except) {
-		SetStreamBroken(OT_CODE_STAMP + " Got exception when opening debug channel: " + ToStr(except.what()));
-	}
-	catch (...) {
-		SetStreamBroken(OT_CODE_STAMP + " Got not-standard exception when opening debug channel.");
-	}
-}
-
-void cLogger::OpenNewChannel_(const std::string & channel) { // channel=="net/sleep"
-	_dbg_dbg("Openning channel for channel="<<channel);
-	size_t last_split = channel.find_last_of(cFilesystemUtils::GetDirSeparatorInter());
-
-	string fname_system; // the full file name in system format
-
-	if (last_split==string::npos) { // The channel name has no directory, eg channel=="test"
-		string dir = GetLogBaseDir();
-		string basefile = channel + ".log";
-		string fname = dir + cFilesystemUtils::GetDirSeparatorInter() + basefile;
-		fname_system = cFilesystemUtils::FileInternalToSystem(fname); // <-
-	}
-	else { // there is a directory eg channel=="net/sleep"
-		// net/sleep 
-		//    ^----- last_split	
-		string dir = GetLogBaseDir() + cFilesystemUtils::GetDirSeparatorInter() + channel.substr(0, last_split);
-		string basefile = channel.substr(last_split+1) + ".log";
-		string fname = dir + cFilesystemUtils::GetDirSeparatorInter() + basefile;
-		fname_system = cFilesystemUtils::FileInternalToSystem(fname); // <-
-		bool dirok = cFilesystemUtils::CreateDirTree(dir);
-		if (!dirok) { string err = "In logger failed to open directory (" + dir +") for channel (" + channel +")"; throw std::runtime_error(err); }
-	}
-
-	_dbg_dbg("Openning fname_system="<<fname_system);
-	std::ofstream * thefile = new std::ofstream( fname_system.c_str() ); // file system
-	*thefile << "====== Log opened: " << fname_system << " (in " << ((void*)thefile) << ") ======" << endl;
-//    	cerr << "====== Log opened: " << fname_system << " (in " << ((void*)thefile) << ") ======" << endl;
-  	_dbg_dbg( "====== Log opened: " << fname_system << " (in " << ((void*)thefile) << ") ======" );
-	mChannels.insert( std::pair<string,std::ofstream*>(channel , thefile ) ); // <- created the channel mapping
-}
-
-std::ostream & cLogger::SelectOutput(int level, const std::string & channel) noexcept {
-	try {
-		if (mIsBroken) { 
-			_dbg_dbg("The stream is broken mIsBroken="<<mIsBroken<<" so will return backup stream");
-			return *mStreamBrokenDebug;
-		}
-		if (channel=="") { 
-			_dbg_dbg("No channel given (channel="<<channel<<") so will return main stream");
-			return *mStream;
-		}
-
-		auto obj = mChannels.find(channel);
-		if (obj == mChannels.end()) { // not found - need to make new channel
-			_dbg_dbg("No stream openened for channel="<<channel<<" so will create it now");
-			OpenNewChannel(channel); // <- create channel
-			obj = mChannels.find(channel); // find again
-			if (obj == mChannels.end()) { // still not found! something is wrong
-				SetStreamBroken( OT_CODE_STAMP + " WARNING: can not get stream for channel="+ToStr(channel)+" level="+ToStr(channel) );
-				return *mStreamBrokenDebug;
-			}
-		}
-		auto the_stream_ptr = obj->second;
-		_dbg_dbg("Found the stream file for channel="<<channel<<" as the_stream_ptr="<<the_stream_ptr);
-		ASRT(the_stream_ptr);
-		return *the_stream_ptr; // <--- RETURN
-	} 
-	catch (std::exception &except) { 
-		SetStreamBroken( OT_CODE_STAMP + " Got exception: " + ToStr(except.what()) );
-		_dbg_dbg("Exception! Returning broken stream");
-		return *mStreamBrokenDebug;
-	}
-	catch (...) {
-		SetStreamBroken( OT_CODE_STAMP + " Got not-standard exception.");
-		_dbg_dbg("Exception! Returning broken stream");
-		return *mStreamBrokenDebug;
-	}
-
-	// dead code
-}
-
-void cLogger::setOutStreamFile(const string &fname) { // switch to using this file
-	_mark("WILL SWITCH DEBUG NOW to file: " << fname);
-	mOutfile =  make_unique<std::ofstream>(fname);
-	mStream = & (*mOutfile);
-	_mark("Started new debug, to file: " << fname);
-}
-
-void cLogger::setOutStreamFromGlobalOptions() {
-	if ( gRunOptions.getDebug() ) {
-		if ( gRunOptions.getDebugSendToFile() ) {
-			mOutfile =  make_unique<std::ofstream> ("debuglog.txt");
-			mStream = & (*mOutfile);
-		}
-		else if ( gRunOptions.getDebugSendToCerr() ) {
-			mStream = & std::cerr;
-		}
-		else {
-			mStream = & g_nullstream;
-		}
-	}
-	else {
-		mStream = & g_nullstream;
-	}
-}
-
-void cLogger::setDebugLevel(int level) {
-	bool note_before = (mLevel > level); // report the level change before or after the change? (on higher level)
-	if (note_before) _note("Setting debug level to "<<level);
-	mLevel = level;
-	if (!note_before) _note("Setting debug level to "<<level);
-}
-
-std::string cLogger::icon(int level) const {
-	// TODO replan to avoid needles converting back and forth char*, string etc
-
-	using namespace zkr;
-    #if defined(OS_TYPE_POSIX)
-	if (level >= 100) return cc::back::lightred     + ToStr(cc::fore::lightyellow) + ToStr("ERROR ") + ToStr(cc::fore::lightyellow) + " " ;
-	if (level >=  90) return cc::back::lightyellow  + ToStr(cc::fore::black) + ToStr("Warn  ") + ToStr(cc::fore::red)+ " " ;
-	if (level >=  80) return cc::back::lightmagenta + ToStr(cc::fore::black) + ToStr("MARK  "); //+ zkr::cc::console + ToStr(cc::fore::lightmagenta)+ " ";
-    if (level >=  75) return cc::back::lightyellow + ToStr(cc::fore::black) + ToStr("FACT  ") + zkr::cc::console + ToStr(cc::fore::lightyellow)+ " ";
-	if (level >=  70) return cc::fore::green    + ToStr("Note  ");
-	if (level >=  50) return cc::fore::cyan   + ToStr("info  ");
-	if (level >=  40) return cc::fore::lightwhite    + ToStr("dbg   ");
-	if (level >=  30) return cc::fore::lightblue   + ToStr("dbg   ");
-	if (level >=  20) return cc::fore::blue    + ToStr("dbg   ");
-
-    #elif defined(OS_TYPE_WINDOWS)
-    if (level >= 100) return ToStr("ERROR ");
-    if (level >=  90) return ToStr("Warn  ");
-    if (level >=  80) return ToStr("MARK  ");
-    if (level >=  75) return ToStr("FACT  ");
-    if (level >=  70) return ToStr("Note  ");
-    if (level >=  50) return ToStr("info  ");
-    if (level >=  40) return ToStr("dbg   ");
-    if (level >=  30) return ToStr("dbg   ");
-    if (level >=  20) return ToStr("dbg   ");
-    #endif
-
-	return "  ";
-}
-
-std::string cLogger::endline() const {
-	#if defined(OS_TYPE_POSIX)
-	return ToStr("") + zkr::cc::console + ToStr("\n"); // TODO replan to avoid needles converting back and forth char*, string etc
-    #elif defined(OS_TYPE_WINDOWS)
-    return ToStr("\n");
-    #endif
-}
-
-int cLogger::Thread2Number(const boost::thread::id id) {
-	auto found = mThread2Number.find( id );
-	if (found == mThread2Number.end()) { // new one
-		mThread2Number_Biggest++;
-		mThread2Number[id] = mThread2Number_Biggest;
-		_info_c("dbg/main", "This is a new thread (used in debug), thread id="<<id); // can cause some recursion
-		return mThread2Number_Biggest;
-	} else {
-		return mThread2Number[id];
-	}
-}
-
-int cLogger::Pid2Number(const t_anypid id) {
-	auto found = mPid2Number.find( id );
-	if (found == mPid2Number.end()) { // new one
-		mPid2Number_Biggest++;
-		mPid2Number[id] = mPid2Number_Biggest;
-		_info_c("dbg/main", "This is a new process (used in debug), process pid="<<id); // can cause some recursion
-		return mPid2Number_Biggest;
-	} else {
-		return mPid2Number[id];
-	}
-}
-
-// ====================================================================
-// object gCurrentLogger is defined later - in global namespace below
-
-
-// ====================================================================
-// vector debug
-
-void DisplayStringEndl(std::ostream & out, const std::string text) {
-	out << text;
-	out << std::endl;
-}
-
-std::string SpaceFromEscape(const std::string &s) {
-	std::ostringstream  newStr;
-		for(size_t i = 0; i < s.length();i++) {
-			if(s[i] == '\\' && s[i+1] ==32)
-				newStr<<"";
-			else
-				newStr<<s[i];
-			}
-	return newStr.str();
-}
-
-std::string EscapeFromSpace(const std::string &s) {
-	std::ostringstream  newStr;
-	for(size_t i = 0; i < s.length();i++) {
-		if(s[i] == 32)
-			newStr << "\\" << " ";
-		else
-			newStr << s[i];
-	}
-	return newStr.str();
-}
-
-
-std::string EscapeString(const std::string &s) {
-	std::ostringstream  newStr;
-		for(size_t i = 0; i < s.length();i++) {
-			if(s[i] >=32 && s[i] <= 126)
-				newStr<<s[i];
-			else
-				newStr<<"\\"<< (int) s[i];
-			}
-
-	return newStr.str();
-}
-
-
-bool CheckIfBegins(const std::string & beggining, const std::string & all) {
-	if (all.compare(0, beggining.length(), beggining) == 0) {
-		return 1;
-	}
-	else {
-		return 0;
-	}
-}
-
-bool CheckIfEnds (std::string const & ending, std::string const & all){
-	if (all.length() >= ending.length()) {
-		return (0 == all.compare (all.length() - ending.length(), ending.length(), ending));
-	} else {
-		return false;
-	}
-}
-
-
-vector<string> WordsThatMatch(const std::string & sofar, const vector<string> & possib) {
-	vector<string> ret;
-	for ( auto rec : possib) { // check of possibilities
-		if (CheckIfBegins(sofar,rec)) {
-			rec = EscapeFromSpace(rec);
-			ret.push_back(rec); // this record matches
-		}
-	}
-	return ret;
-}
-
-char GetLastChar(const std::string & str) { // TODO unicode?
-	auto s = str.length();
-	if (s==0) throw std::runtime_error("Getting last character of empty string (" + ToStr(s) + ")" + OT_CODE_STAMP);
-	return str.at( s - 1);
-}
-
-std::string GetLastCharIf(const std::string & str) { // TODO unicode?
-	auto s = str.length();
-	if (s==0) return ""; // empty string signalizes ther is nothing to be returned
-	return std::string( 1 , str.at( s - 1) );
-}
-
-// ====================================================================
-
-// ASRT - assert. Name like ASSERT() was too long, and ASS() was just... no.
-// Use it like this: ASRT( x>y );  with the semicolon at end, a clever trick forces this syntax :)
-
-void Assert(bool result, const std::string &stamp, const std::string &condition) {
-	if (!result) {
-		_erro("Assert failed at "+stamp+": ASSERT( " << condition << ")");
-		throw std::runtime_error("Assert failed at "+stamp+": ASSERT( " + condition + ")");
-	}
-}
-
-// ====================================================================
-// advanced string
-
-const std::string GetMultiline(string endLine) {
-	std::string result(""); // Taken from OT_CLI_ReadUntilEOF
-	while (true) {
-		std::string input_line("");
-		if (std::getline(std::cin, input_line, '\n'))
-		{
-			input_line += "\n";
-				if (input_line[0] == '~')
-					break;
-			result += input_line;
-		}
-		if (std::cin.eof() )
-		{
-			std::cin.clear();
-				break;
-		}
-		if (std::cin.fail() )
-		{
-			std::cin.clear();
-				break;
-		}
-		if (std::cin.bad())
-		{
-			std::cin.clear();
-				break;
-		}
-	}
-	return result;
-}
-
-vector<string> SplitString(const string & str){
-		std::istringstream iss(str);
-		vector<string> vec { std::istream_iterator<string>{iss}, std::istream_iterator<string>{} };
-		return vec;
-}
-
-bool checkPrefix(const string & str, char prefix) {
-	if (str.at(0) == prefix)
-		return true;
-	return false;
-}
-
-// ====================================================================
-// operation on files
-
-
-#ifdef __unix
-
-void cEnvUtils::GetTmpTextFile() {
-	// TODO make this name configurable (depending on project)
-	char filename[] = "/tmp/otshellutils_text.XXXXXX";
-	fd = mkstemp(filename);
-	if (fd == -1) {
-		_erro("Can't create the file: " << filename);
-		return;
-	}
-	mFilename = filename;
-}
-
-void cEnvUtils::CloseFile() {
-	close(fd);
-	unlink( mFilename.c_str() );
-}
-
-void  cEnvUtils::OpenEditor() {
-	char* editor = std::getenv("OT_EDITOR"); //TODO Read editor from configuration file
-	if (editor == NULL)
-		editor = std::getenv("VISUAL");
-	if (editor == NULL)
-		editor = std::getenv("EDITOR");
-
-	string command;
-	if (editor != NULL)
-		command = ToStr(editor) + " " + mFilename;
-	else
-		command = "/usr/bin/editor " + mFilename;
-	_dbg3("Opening editor with command: " << command);
-	if ( system( command.c_str() ) == -1 )
-		_erro("Cannot execute system command: " << command);
-}
-
-const string cEnvUtils::ReadFromTmpFile() {
-	std::ifstream ifs(mFilename);
-	string msg((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
-	return msg;
-}
-
-const string cEnvUtils::Compose() {
-	GetTmpTextFile();
-	OpenEditor();
-	string input = ReadFromTmpFile();
-	CloseFile();
-	return input;
-}
-
-#endif
-
-const string cEnvUtils::ReadFromFile(const string path) {
-	std::ifstream ifs(path);
-	string msg((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
-	return msg;
-}
-
-void hintingToTxt(std::fstream & file, string command, vector<string> &commands) {
-	if(file.good()) {
-		file<<command<<"~"<<endl;
-		for (auto a: commands) {
-			file <<a<< " ";
-			file.flush();
-		}
-		file<<endl;
-	}
-}
-
-string stringToColor(const string &hash) {
-  // Generete vector with all possible light colors
-  vector <string> lightColors;
-  using namespace zkr;
-  lightColors.push_back(cc::fore::lightblue);
-  lightColors.push_back(cc::fore::lightred);
-  lightColors.push_back(cc::fore::lightmagenta);
-  lightColors.push_back(cc::fore::lightgreen);
-  lightColors.push_back(cc::fore::lightcyan);
-  lightColors.push_back(cc::fore::lightyellow);
-  lightColors.push_back(cc::fore::lightwhite);
-
-  int sum=0;
-
-  for (auto ch : hash) sum+=ch;
-  auto color = sum%(lightColors.size()-1);
-
-  return lightColors.at( color );
-}
-
-
-// ====================================================================
-// algorthms
-
-
-} // namespace nUtil
-
-
-} // namespace OT
-
-// global namespace
-
-const extern int _dbg_ignore = 0; // see description in .hpp
-
-std::string GetObjectName() {
-	//static std::string * name=nullptr;
-	//if (!name) name = new std::string("(global)");
-	return "";
-}
-
-// ====================================================================
-
-nOT::nUtils::cLogger gCurrentLogger;
-

contrib/otshell_utils/utils.hpp

@@ -1,532 +0,0 @@
-/// @file
-/// @author rfree (current maintainer in monero.cc project)
-/// @brief various general utils taken from (and relate to) otshell project, including loggiang/debug
-
-/* See other files here for the LICENCE that applies here. */
-
-#include "ccolor.hpp"
-#ifndef INCLUDE_OT_NEWCLI_UTILS
-#define INCLUDE_OT_NEWCLI_UTILS
-
-#include "lib_common1.hpp"
-#ifdef __unix
-	#include <unistd.h>
-#endif
-
-#if defined(_WIN32)
-    #include"windows_stream.h"
-#endif
-
-#ifndef CFG_WITH_TERMCOLORS
-	//#error "You requested to turn off terminal colors (CFG_WITH_TERMCOLORS), however currently they are hardcoded (this option to turn them off is not yet implemented)."
-#endif
-
-///Macros related to automatic deduction of class name etc; 
-#define MAKE_CLASS_NAME(NAME) private: static std::string GetObjectName() { return #NAME; }
-#define MAKE_STRUCT_NAME(NAME) private: static std::string GetObjectName() { return #NAME; } public:
-
-// define this to debug the debug system itself:
-// #define opt_debug_debug
-
-#ifdef opt_debug_debug
-	#define _dbg_dbg(X) do { std::cerr<<"_dbg_dbg: " << OT_CODE_STAMP << " {thread=" << boost::this_thread::get_id()<<"} " \
-	<< " {pid="<<getpid()<<"} " <<  ": " << X << std::endl; } while(0)
-#else
-	#define _dbg_dbg(X) do { } while(0)
-#endif
-
-namespace nOT {
-
-namespace nUtils {
-
-/// @brief general based for my runtime errors
-class myexception : public std::runtime_error {
-	public:
-		myexception(const char * what);
-		myexception(const std::string &what);
-        //virtual ~myexception();
-		virtual void Report() const;
-};
-
-/// @macro Use this macro INJECT_OT_COMMON_USING_NAMESPACE_COMMON_1 as a shortcut for various using std::string etc.
-INJECT_OT_COMMON_USING_NAMESPACE_COMMON_1 // <=== namespaces
-
-// ======================================================================================
-/// text trimming functions (they do mutate the passes string); they trim based on std::isspace. also return it's reference again
-/// http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
-std::string & trim(std::string &s); ///< trim text http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
-std::string & ltrim(std::string &s); ///< left trim
-std::string & rtrim(std::string &s); ///< right trim
-
-// ======================================================================================
-
-std::string get_current_time();
-
-// string conversions
-template <class T>
-std::string ToStr(const T & obj) {
-	std::ostringstream oss;
-	oss << obj;
-	return oss.str();
-}
-
-struct cNullstream : std::ostream {
-	cNullstream() : std::ios(0), std::ostream(0) {}
-};
-extern cNullstream g_nullstream; // a stream that does nothing (eats/discards data)
-// ========== debug ==========
-// _dbg_ignore is moved to global namespace (on purpose)
-
-// TODO make _dbg_ignore thread-safe everywhere
-
-extern boost::recursive_mutex gLoggerGuard; // the mutex guarding logging/debugging code e.g. protecting streams, files, etc
-
-std::atomic<int> & gLoggerGuardDepth_Get(); // getter for the global singleton of counter (it guarantees initializing it to 0). This counter shows the current recursion (re-entrant) level of debug macros.
-
-// TODO more debug of the debug system:
-// detect lock() error e.g. recursive limit
-// detect stream e.g. operator<< error
-
-#define _debug_level(LEVEL,VAR) do { if (_dbg_ignore< LEVEL) { \
-	_dbg_dbg("WRITE DEBUG: LEVEL="<<LEVEL<<" VAR: " << VAR ); \
-	auto level=LEVEL; short int part=0; \
-	try { \
-		boost::lock_guard<boost::recursive_mutex> mutex_guard( nOT::nUtils::gLoggerGuard ); \
-		part=1; \
-		try { \
-			++nOT::nUtils::gLoggerGuardDepth_Get(); \
-/* int counter = nOT::nUtils::gLoggerGuardDepth_Get();  if (counter!=1) gCurrentLogger.write_stream(100,"")<<"DEBUG-ERROR: recursion, counter="<<counter<<gCurrentLogger.endline(); */ \
-			gCurrentLogger.write_stream(LEVEL,"") << nOT::nUtils::get_current_time() << ' ' << OT_CODE_STAMP << ' ' << VAR << gCurrentLogger.endline() << std::flush; \
-			part=9; \
-		} catch(...) { \
-			gCurrentLogger.write_stream(std::max(level,90),"") << nOT::nUtils::get_current_time() << ' ' << OT_CODE_STAMP << ' ' << "(ERROR IN DEBUG)" << gCurrentLogger.endline(); \
-			--nOT::nUtils::gLoggerGuardDepth_Get(); throw ; \
-		} \
-		--nOT::nUtils::gLoggerGuardDepth_Get(); \
-	} catch(...) { if (part<8) gCurrentLogger.write_stream(100,"")<<"DEBUG-ERROR: problem in debug mechanism e.g. in locking." <<gCurrentLogger.endline();   throw ; } \
-	} } while(0)
-
-// info for code below: oss object is normal stack variable, using it does not need lock protection
-#define _debug_level_c(CHANNEL,LEVEL,VAR) do { if (_dbg_ignore< LEVEL) { \
-	_dbg_dbg("WRITE DEBUG: LEVEL="<<LEVEL<<" CHANNEL="<<CHANNEL<<" VAR: " << VAR ); \
-	auto level=LEVEL; short int part=0; \
-	try { \
-		boost::lock_guard<boost::recursive_mutex> mutex_guard( nOT::nUtils::gLoggerGuard ); \
-		part=1; \
-		try { \
-			++nOT::nUtils::gLoggerGuardDepth_Get(); \
-			std::ostringstream oss; \
-			oss << nOT::nUtils::get_current_time() << ' ' << OT_CODE_STAMP << ' ' << VAR << gCurrentLogger.endline() << std::flush; \
-			std::string as_string = oss.str(); \
-			_dbg_dbg("START will write to log LEVEL="<<LEVEL<<" to CHANNEL="<<CHANNEL<<" as_string="<<as_string); \
-/* int counter = nOT::nUtils::gLoggerGuardDepth_Get();  if (counter!=1) gCurrentLogger.write_stream(100,"")<<"DEBUG-ERROR: recursion, counter="<<counter<<gCurrentLogger.endline(); */ \
-			gCurrentLogger.write_stream(LEVEL,""     ) << as_string << gCurrentLogger.endline() << std::flush; \
-			gCurrentLogger.write_stream(LEVEL,CHANNEL) << as_string << gCurrentLogger.endline() << std::flush; \
-			_dbg_dbg("DONE will write to log LEVEL="<<LEVEL<<" to CHANNEL="<<CHANNEL<<" as_string="<<as_string); \
-			part=9; \
-		} catch(...) { \
-			gCurrentLogger.write_stream(std::max(level,90),CHANNEL) << nOT::nUtils::get_current_time() << ' ' << OT_CODE_STAMP << ' ' << "(ERROR IN DEBUG)" << gCurrentLogger.endline(); \
-			--nOT::nUtils::gLoggerGuardDepth_Get(); throw ; \
-		} \
-		--nOT::nUtils::gLoggerGuardDepth_Get(); \
-	} catch(...) { if (part<8) gCurrentLogger.write_stream(100,CHANNEL)<<"DEBUG-ERROR: problem in debug mechanism e.g. in locking." <<gCurrentLogger.endline();   throw ; } \
-	} } while(0)
-
-// Numerical values of the debug levels - are defined here as const ints. Full name (with namespace) given for clarity.
-extern const int _debug_level_nr_dbg3;
-extern const int _debug_level_nr_dbg2;
-extern const int _debug_level_nr_dbg1;
-extern const int _debug_level_nr_info;
-extern const int _debug_level_nr_note;
-extern const int _debug_level_nr_fact;
-extern const int _debug_level_nr_mark;
-extern const int _debug_level_nr_warn;
-extern const int _debug_level_nr_erro;
-
-#define _dbg3(VAR) _debug_level( nOT::nUtils::_debug_level_nr_dbg3,VAR) // details - most detailed
-#define _dbg2(VAR) _debug_level( nOT::nUtils::_debug_level_nr_dbg2,VAR) // details - a bit more important
-#define _dbg1(VAR) _debug_level( nOT::nUtils::_debug_level_nr_dbg1,VAR) // details - more important
-#define _info(VAR) _debug_level( nOT::nUtils::_debug_level_nr_info,VAR) // information
-#define _note(VAR) _debug_level( nOT::nUtils::_debug_level_nr_note,VAR) // more interesting information
-#define _fact(VAR) _debug_level( nOT::nUtils::_debug_level_nr_fact,VAR) // interesting events that could be interesting even for user, for logical/business things
-#define _mark(VAR) _debug_level( nOT::nUtils::_debug_level_nr_mark,VAR) // marked actions
-#define _warn(VAR) _debug_level( nOT::nUtils::_debug_level_nr_warn,VAR) // some problems
-#define _erro(VAR) _debug_level( nOT::nUtils::_debug_level_nr_erro,VAR) // errors
-
-#define _dbg3_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_dbg3, VAR) // details - most detailed
-#define _dbg2_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_dbg2, VAR) // details - a bit more important
-#define _dbg1_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_dbg1, VAR) // details - more important
-#define _info_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_info, VAR) // information
-#define _note_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_note, VAR) // more interesting information
-#define _fact_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_fact, VAR) // interesting events that could be interesting even for user, for logical/business things
-#define _mark_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_mark, VAR) // marked actions
-#define _warn_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_warn, VAR) // some problems
-#define _erro_c(C,VAR) _debug_level_c(C, nOT::nUtils::_debug_level_nr_erro, VAR) // errors
-
-// lock // because of VAR
-#define _scope_debug_level_c(CHANNEL,LEVEL,VAR) \
-	std::ostringstream debug_detail_oss; \
-	nOT::nUtils::gLoggerGuard.lock(); \
-	debug_detail_oss << OT_CODE_STAMP << ' ' << VAR ; \
-	nOT::nUtils::nDetail::cDebugScopeGuard debugScopeGuard; \
-	if (_dbg_ignore<LEVEL) debugScopeGuard.Assign(CHANNEL,LEVEL, debug_detail_oss.str()); \
-	if (_dbg_ignore<LEVEL) _debug_level_c(CHANNEL,LEVEL,debug_detail_oss.str() + " ... begin"); \
-	nOT::nUtils::gLoggerGuard.unlock();
-#define _scope_debug_level(LEVEL,VAR) _scope_debug_level_c("",LEVEL,VAR)
-
-#define _scope_dbg1(VAR) _scope_debug_level( _debug_level_nr_dbg3, VAR)
-#define _scope_dbg2(VAR) _scope_debug_level( _debug_level_nr_dbg2, VAR)
-#define _scope_dbg3(VAR) _scope_debug_level( _debug_level_nr_dbg1, VAR) 
-#define _scope_info(VAR) _scope_debug_level( _debug_level_nr_info, VAR) 
-#define _scope_note(VAR) _scope_debug_level( _debug_level_nr_note, VAR) 
-#define _scope_fact(VAR) _scope_debug_level( _debug_level_nr_fact, VAR) 
-#define _scope_mark(VAR) _scope_debug_level( _debug_level_nr_mark, VAR) 
-#define _scope_warn(VAR) _scope_debug_level( _debug_level_nr_warn, VAR) 
-#define _scope_erro(VAR) _scope_debug_level( _debug_level_nr_erro, VAR) 
-
-/***
-@brief do not use this namespace directly, it is implementation detail.
-*/
-namespace nDetail { 
-
-/***
-@brief a Debug scope-guard, to log a debug message when current scope is left. Do NOT use this directly,
-only use it via the macros like _scope_dbg1 etc.
-*/
-class cDebugScopeGuard {
-	protected:
-		string mMsg;
-		int mLevel;
-		string mChan;
-	public:
-		cDebugScopeGuard();
-		~cDebugScopeGuard();
-		void Assign(const string &chan, const int level, const string &msg);
-};
-
-const char* DbgShortenCodeFileName(const char *s); ///< Returns a pointer to some part of the string that was given, skipping directory names, for log/debug
-
-} // namespace nDetail
-
-// ========== logger ==========
-
-namespace nDetail {
-	struct channel_use_info;
-} // namespace nDetail
-
-/*** 
-@brief Class to write debug into. Used it by calling the debug macros _dbg1(...) _info(...) _erro(...) etc, NOT directly!
-@author rfree (maintainer) 
-@thread this class is NOT thread safe and must used only by one thread at once (use it via ot_debug_macros like _info macro they do proper locking)
-*/
-class cLogger {
-	public:
-		cLogger();
-		~cLogger();
-		std::ostream & write_stream(int level); ///< starts a new message on given level (e.g. writes out the icon/tag) and returns stream to output to
-		std::ostream & write_stream(int level, const std::string & channel); ///< the same but with name of the debug channel
-
-		void setOutStreamFromGlobalOptions(); // set debug level, file etc - according to global Options
-		void setOutStreamFile(const std::string &fname); // switch to using this file
-		void setDebugLevel(int level); // change the debug level e.g. to mute debug from now
-
-		std::string icon(int level) const; ///< returns "icon" for given debug level. It is text, might include color controll characters
-		std::string endline() const; ///< returns string to be written at end of message
-
-	protected:
-		typedef long int t_anypid; // a portable representation of PID. long int should cover all platforms
-
-		void SetStreamBroken(); ///< call in case of internal error in logger (e.g. can not open a file)
-		void SetStreamBroken(const std::string &msg); ///< same but with error message
-
-		unique_ptr<std::ofstream> mOutfile;
-		std::ostream * mStream; ///< pointing only! can point to our own mOutfile, or maye to global null stream
-		std::ostream * mStreamBrokenDebug; ///< pointing only! this is a pointer to some stream that should be used when normal debugging is broken eg std::cerr
-		bool mIsBroken; ///< is the debugging system broken (this should be set when internal problems occur and should cause fallback to std::cerr)
-
-		std::map< std::string , std::ofstream * > mChannels; // the ofstream objects are owned by this class
-
-		int mLevel; ///< current debug level
-
-		std::ostream & SelectOutput(int level, const std::string & channel) noexcept; ///< returns a proper stream for this level and channel (always usable string)
-		void OpenNewChannel(const std::string & channel) noexcept; ///< tries to prepare this channel. does NOT guarantee to created mChannels[] entry!
-		void OpenNewChannel_(const std::string & channel);  ///< internal function, will throw in case of problems
-		std::string GetLogBaseDir() const;
-
-		std::map< boost::thread::id , int > mThread2Number; ///<  change long thread IDs into a short nice number to show
-		int mThread2Number_Biggest; ///<  current biggest value held there (biggest key) - works as growing-only counter basically
-		int Thread2Number(const boost::thread::id id); ///<  convert the system's thread id into a nice short our id; make one if new thread
-
-		std::map< t_anypid , int > mPid2Number; ///<  change long proces PID into a short nice number to show
-		int mPid2Number_Biggest; ///<  current biggest value held there (biggest key) - works as growing-only counter basically
-		int Pid2Number(const t_anypid id); ///<  convert the system's PID id into a nice short our id; make one if new thread
-};
-
-
-
-// ====================================================================
-// vector debug
-
-template <class T>
-std::string vectorToStr(const T & v) {
-	std::ostringstream oss;
-	for(auto rec: v) {
-		oss << rec <<",";
-		}
-	return oss.str();
-}
-
-template <class T>
-void DisplayVector(std::ostream & out, const std::vector<T> &v, const std::string &delim=" ") {
-	std::copy( v.begin(), v.end(), std::ostream_iterator<T>(out, delim.c_str()) );
-}
-
-template <class T>
-void EndlDisplayVector(std::ostream & out, const std::vector<T> &v, const std::string &delim=" ") {
-	out << std::endl;
-	DisplayVector(out,v,delim);
-}
-
-template <class T>
-void DisplayVectorEndl(std::ostream & out, const std::vector<T> &v, const std::string &delim=" ") {
-	DisplayVector(out,v,delim);
-	out << std::endl;
-}
-
-template <class T>
-void DbgDisplayVector(const std::vector<T> &v, const std::string &delim=" ") {
-	std::cerr << "[";
-	std::copy( v.begin(), v.end(), std::ostream_iterator<T>(std::cerr, delim.c_str()) );
-	std::cerr << "]";
-}
-
-string stringToColor(const string &hash);
-template <class T, class T2>
-void DisplayMap(std::ostream & out, const std::map<T, T2> &m, const std::string &delim=" ") {
-	auto *no_color = zkr::cc::fore::console;
-	for(auto var : m) {
-		out << stringToColor(var.first) << var.first << delim << var.second << no_color << endl;
-	}
-
-}
-
-template <class T, class T2>
-void EndlDisplayMap(std::ostream & out, const std::map<T, T2> &m, const std::string &delim=" ") {
-	out << endl;
-	for(auto var : m) {
-		out << var.first << delim << var.second << endl;
-	}
-}
-
-template <class T, class T2>
-void DbgDisplayMap(const std::map<T, T2> &m, const std::string &delim=" ") {
-	for(auto var : m) {
-		std::cerr << var.first << delim << var.second << endl;
-	}
-}
-
-
-template <class T>
-void DbgDisplayVectorEndl(const std::vector<T> &v, const std::string &delim=" ") {
-	DbgDisplayVector(v,delim);
-	std::cerr << std::endl;
-}
-
-void DisplayStringEndl(std::ostream & out, const std::string text);
-
-bool CheckIfBegins(const std::string & beggining, const std::string & all);
-bool CheckIfEnds (std::string const & ending, std::string const & all);
-std::string SpaceFromEscape(const std::string &s);
-std::string EscapeFromSpace(const std::string &s);
-vector<string> WordsThatMatch(const std::string & sofar, const vector<string> & possib);
-char GetLastChar(const std::string & str);
-std::string GetLastCharIf(const std::string & str); // TODO unicode?
-std::string EscapeString(const std::string &s);
-
-
-template <class T>
-std::string DbgVector(const std::vector<T> &v, const std::string &delim="|") {
-	std::ostringstream oss;
-	oss << "[";
-	bool first=true;
-	for(auto vElement : v) { if (!first) oss<<delim; first=false; oss <<vElement ; }
-	oss << "]";
-	//std::copy( v.begin(), v.end(), std::ostream_iterator<T>(oss, delim.c_str()) );
-	return oss.str();
-}
-
-template <class T>
-std::ostream & operator<<(std::ostream & os, const map< T, vector<T> > & obj){
-	os << "[";
-	for(auto const & elem : obj) {
-		os << " [" << elem.first << "=" << DbgVector(elem.second) << "] ";
-	}
-	os << "]";
-  return os;
-}
-
-template <class T, class T2>
-std::string DbgMap(const map<T, T2> & map) {
-	std::ostringstream oss;
-		oss << map;
-	return oss.str();
-}
-
-// ====================================================================
-// assert
-
-// ASRT - assert. Name like ASSERT() was too long, and ASS() was just... no.
-// Use it like this: ASRT( x>y );  with the semicolon at end, a clever trick forces this syntax :)
-#define ASRT(x) do { if (!(x)) nOT::nUtils::Assert(false, OT_CODE_STAMP, #x); } while(0)
-
-void Assert(bool result, const std::string &stamp, const std::string &condition);
-
-// ====================================================================
-// advanced string
-
-const std::string GetMultiline(string endLine = "~");
-vector<string> SplitString(const string & str);
-
-bool checkPrefix(const string & str, char prefix = '^');
-
-// ====================================================================
-// nUse utils
-
-enum class eSubjectType {Account, Asset, User, Server, Unknown};
-
-string SubjectType2String(const eSubjectType & type);
-eSubjectType String2SubjectType(const string & type);
-
-// ====================================================================
-// operation on files
-
-/// @brief tools related to filesystem
-/// @author rfree (maintainer)
-class cFilesystemUtils { // if we do not want to use boost in given project (or we could optionally write boost here later)
-	public:
-		static bool CreateDirTree(const std::string & dir, bool only_below=false);
-		static char GetDirSeparatorSys(); /// < eg '/' or '\'
-		static char GetDirSeparatorInter(); /// < internal is '/'
-		static string FileInternalToSystem(const std::string &name); ///< converts from internal file name string to system file name string
-		static string FileSystemToInternal(const std::string &name); ///< converts from system file name string to internal file name string
-};
-
-
-/// @brief utils to e.g. edit a file from console
-/// @author rfree (maintainer)
-class cEnvUtils {
-	int fd;
-	string mFilename;
-
-	void GetTmpTextFile();
-	void CloseFile();
-	void OpenEditor();
-	const string ReadFromTmpFile();
-public:
-	const string Compose();
-	const string ReadFromFile(const string path);
-};
-void hintingToTxt(std::fstream & file, string command, vector<string> &commands);
-void generateQuestions (std::fstream & file, string command);
-void generateAnswers (std::fstream & file, string command, vector<string> &completions);
-
-// ====================================================================
-
-namespace nOper { // nOT::nUtils::nOper
-// cool shortcut operators, like vector + vecotr operator working same as string (appending)
-// isolated to namespace because it's unorthodox ide to implement this
-
-using namespace std;
-
-// TODO use && and move?
-template <class T>
-vector<T> operator+(const vector<T> &a, const vector<T> &b) {
-	vector<T> ret = a;
-	ret.insert( ret.end() , b.begin(), b.end() );
-	return ret;
-}
-
-template <class T>
-vector<T> operator+(const T &a, const vector<T> &b) {
-	vector<T> ret(1,a);
-	ret.insert( ret.end() , b.begin(), b.end() );
-	return ret;
-}
-
-template <class T>
-vector<T> operator+(const vector<T> &a, const T &b) {
-	vector<T> b_vector(1,a);
-	return a + b_vector;
-}
-
-template <class T>
-vector<T>& operator+=(vector<T> &a, const vector<T> &b) {
-	a.insert( a.end() , b.begin(), b.end() );
-	return a;
-}
-
-// map
-template <class TK,class TV>
-map<TK,TV> operator+(const map<TK,TV> &a, const map<TK,TV> &b) {
-	map<TK,TV> ret = a;
-	for (const auto & elem : b) {
-		ret.insert(elem);
-	}
-	return ret;
-}
-
-
-} // nOT::nUtils::nOper
-
-// ====================================================================
-
-// ====================================================================
-
-// Algorithms
-
-// ====================================================================
-// ====================================================================
-
-
-/**
-@brief Special type that on creation will be initialized to have value INIT given as template argument. 
-Might be usefull e.g. to express in the declaration of class what will be the default value of member variable
-See also http://www.boost.org/doc/libs/1_56_0/libs/utility/value_init.htm
-Probably not needed when using boost in your project.
-*/
-template <class T, T INIT>
-class value_init {
-	private:
-		T data;
-	public:
-		value_init();
-
-		T& operator=(const T& v) { data=v; return *this; }
-		operator T const &() const { return data; }
-		operator T&() { return data;	}
-};
-
-template <class T, T INIT>
-value_init<T, INIT>::value_init() :	data(INIT) { }
-
-} // namespace nUtils
-
-} // namespace nOT
-
-
-// global namespace
-extern nOT::nUtils::cLogger gCurrentLogger; ///< The current main logger. Usually do not use it directly, instead use macros like _dbg1 etc
-
-std::string GetObjectName(); ///< Method to return name of current object; To use in debug; Can be shadowed in your classes. (Might be not used currently)
-
-const extern int _dbg_ignore; ///< the global _dbg_ignore, but local code (blocks, classes etc) you could shadow it in your code blocks, 
-// to override debug compile-time setting for given block/class, e.g. to disable debug in one of your methods or increase it there.
-// Or to make it runtime by providing a class normal member and editing it in runtime
-
-#define OT_CODE_STAMP ( nOT::nUtils::ToStr("[") + nOT::nUtils::nDetail::DbgShortenCodeFileName(__FILE__) + nOT::nUtils::ToStr("+") + nOT::nUtils::ToStr(__LINE__) + nOT::nUtils::ToStr(" ") + (GetObjectName()) + nOT::nUtils::ToStr("::") + nOT::nUtils::ToStr(__FUNCTION__) + nOT::nUtils::ToStr("]"))
-
-
-
-
-#endif
-

contrib/otshell_utils/windows_stream.cpp

@@ -1,64 +0,0 @@
-#if defined(_WIN32)
-#include "windows_stream.h"
-#include <windows.h>
-
-windows_stream::windows_stream(unsigned int pLevel)
-    :
-      mLevel(pLevel)
-{
-}
-
-std::ostream& operator << (std::ostream &stream, windows_stream const& object)
-{
-    HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-
-    if (object.mLevel >= 100)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >= 90)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_INTENSITY | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  80)
-    {
-        SetConsoleTextAttribute(h_stdout, BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  75)
-    {
-        SetConsoleTextAttribute(h_stdout, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  70)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  50)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  40)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  30)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
-        return stream;
-    }
-    if (object.mLevel >=  20)
-    {
-        SetConsoleTextAttribute(h_stdout, FOREGROUND_BLUE);
-        return stream;
-    }
-
-    return stream;
-}
-
-#endif

contrib/otshell_utils/windows_stream.h

@@ -1,20 +0,0 @@
-#ifndef WINDOWS_STREAM_H
-#define WINDOWS_STREAM_H
-
-#if defined(_WIN32)
-
-#include <string>
-#include <iostream>
-
-class windows_stream
-{
-public:
-    windows_stream(unsigned int pLevel);
-    friend std::ostream& operator<<(std::ostream &stream, windows_stream const& object);
-private:
-    unsigned int mLevel = 0;
-};
-
-#endif // _WIN32
-
-#endif // WINDOWS_STREAM_H

src/blockchain_db/blockchain_db.cpp

@@ -32,6 +32,9 @@
 #include "cryptonote_core/cryptonote_format_utils.h"
 #include "profile_tools.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "blockchain.db"
+
 using epee::string_tools::pod_to_hex;
 
 namespace cryptonote

src/blockchain_db/lmdb/db_lmdb.cpp

@@ -38,6 +38,10 @@
 #include "crypto/crypto.h"
 #include "profile_tools.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "blockchain.db.lmdb"
+
+
 #if defined(__i386) || defined(__x86_64)
 #define MISALIGNED_OK	1
 #endif
@@ -388,14 +392,14 @@ void BlockchainLMDB::do_resize(uint64_t increase_size)
     boost::filesystem::space_info si = boost::filesystem::space(path);
     if(si.available < add_size)
     {
-      LOG_PRINT_RED_L0("!! WARNING: Insufficient free space to extend database !!: " << si.available / 1LL << 20L);
+      MERROR("!! WARNING: Insufficient free space to extend database !!: " << si.available / 1LL << 20L);
       return;
     }
   }
   catch(...)
   {
     // print something but proceed.
-    LOG_PRINT_YELLOW("Unable to query free disk space.", LOG_LEVEL_0);
+    MWARNING("Unable to query free disk space.");
   }
 
   MDB_envinfo mei;
@@ -437,7 +441,7 @@ void BlockchainLMDB::do_resize(uint64_t increase_size)
   if (result)
     throw0(DB_ERROR(lmdb_error("Failed to set new mapsize: ", result).c_str()));
 
-  LOG_PRINT_GREEN("LMDB Mapsize increased." << "  Old: " << mei.me_mapsize / (1024 * 1024) << "MiB" << ", New: " << new_mapsize / (1024 * 1024) << "MiB", LOG_LEVEL_0);
+  MINFO("LMDB Mapsize increased." << "  Old: " << mei.me_mapsize / (1024 * 1024) << "MiB" << ", New: " << new_mapsize / (1024 * 1024) << "MiB");
 
   mdb_txn_safe::allow_new_txns();
 }
@@ -1168,7 +1172,7 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
   {
     if (*(const uint32_t*)v.mv_data > VERSION)
     {
-      LOG_PRINT_RED_L0("Existing lmdb database was made by a later version. We don't know how it will change yet.");
+      MINFO("Existing lmdb database was made by a later version. We don't know how it will change yet.");
       compatible = false;
     }
 #if VERSION > 0
@@ -1198,8 +1202,8 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
     txn.abort();
     mdb_env_close(m_env);
     m_open = false;
-    LOG_PRINT_RED_L0("Existing lmdb database is incompatible with this version.");
+    MFATAL("Existing lmdb database is incompatible with this version.");
-    LOG_PRINT_RED_L0("Please delete the existing database and resync.");
+    MFATAL("Please delete the existing database and resync.");
     return;
   }
 
@@ -1216,7 +1220,7 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
         txn.abort();
         mdb_env_close(m_env);
         m_open = false;
-        LOG_PRINT_RED_L0("Failed to write version to database.");
+        MERROR("Failed to write version to database.");
         return;
       }
     }
@@ -2864,7 +2868,7 @@ void BlockchainLMDB::fixup()
     ptr = (char *)k.mv_data; \
     ptr[sizeof(name)-2] = 's'
 
-#define LOGIF(y)    if (y <= epee::log_space::log_singletone::get_log_detalisation_level())
+#define LOGIF(y)    if (ELPP->vRegistry()->allowed(y, MONERO_DEFAULT_LOG_CATEGORY))
 
 void BlockchainLMDB::migrate_0_1()
 {
@@ -2875,8 +2879,8 @@ void BlockchainLMDB::migrate_0_1()
   MDB_val k, v;
   char *ptr;
 
-  LOG_PRINT_YELLOW("Migrating blockchain from DB version 0 to 1 - this may take a while:", LOG_LEVEL_0);
+  MLOG_YELLOW(el::Level::Info, "Migrating blockchain from DB version 0 to 1 - this may take a while:");
-  LOG_PRINT_L0("updating blocks, hf_versions, outputs, txs, and spent_keys tables...");
+  MINFO("updating blocks, hf_versions, outputs, txs, and spent_keys tables...");
 
   do {
     result = mdb_txn_begin(m_env, NULL, 0, txn);
@@ -2887,10 +2891,10 @@ void BlockchainLMDB::migrate_0_1()
     if ((result = mdb_stat(txn, m_blocks, &db_stats)))
       throw0(DB_ERROR(lmdb_error("Failed to query m_blocks: ", result).c_str()));
     m_height = db_stats.ms_entries;
-    LOG_PRINT_L0("Total number of blocks: " << m_height);
+    MINFO("Total number of blocks: " << m_height);
-    LOG_PRINT_L1("block migration will update block_heights, block_info, and hf_versions...");
+    MINFO("block migration will update block_heights, block_info, and hf_versions...");
 
-    LOG_PRINT_L1("migrating block_heights:");
+    MINFO("migrating block_heights:");
     MDB_dbi o_heights;
 
     unsigned int flags;
@@ -2925,7 +2929,7 @@ void BlockchainLMDB::migrate_0_1()
     while(1) {
       if (!(i % 2000)) {
         if (i) {
-          LOGIF(1) {
+          LOGIF(el::Level::Info) {
             std::cout << i << " / " << z << "  \r" << std::flush;
           }
           txn.commit();
@@ -3016,7 +3020,7 @@ void BlockchainLMDB::migrate_0_1()
       MDB_val k, v;
       if (!(i % 2000)) {
         if (i) {
-          LOGIF(1) {
+          LOGIF(el::Level::Info) {
             std::cout << i << " / " << z << "  \r" << std::flush;
           }
           txn.commit();
@@ -3148,7 +3152,7 @@ void BlockchainLMDB::migrate_0_1()
     while(1) {
       if (!(i % 2000)) {
         if (i) {
-          LOGIF(1) {
+          LOGIF(el::Level::Info) {
             std::cout << i << " / " << z << "  \r" << std::flush;
           }
           txn.commit();
@@ -3294,7 +3298,7 @@ void BlockchainLMDB::migrate_0_1()
     while(1) {
       if (!(i % 1000)) {
         if (i) {
-          LOGIF(1) {
+          LOGIF(el::Level::Info) {
             std::cout << i << " / " << z << "  \r" << std::flush;
           }
           MDB_val_set(pk, "txblk");

src/blockchain_utilities/CMakeLists.txt

@@ -72,6 +72,7 @@ target_link_libraries(blockchain_import
     cryptonote_core
     blockchain_db
     p2p
+    epee
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_SYSTEM_LIBRARY}
     ${Boost_THREAD_LIBRARY}
@@ -98,6 +99,7 @@ target_link_libraries(blockchain_export
     cryptonote_core
     blockchain_db
     p2p
+    epee
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_SYSTEM_LIBRARY}
     ${Boost_THREAD_LIBRARY}
@@ -118,6 +120,7 @@ target_link_libraries(cn_deserialize
   LINK_PRIVATE
     cryptonote_core
 	p2p
+    epee
     ${CMAKE_THREAD_LIBS_INIT})
 
 add_dependencies(cn_deserialize

src/blockchain_utilities/blockchain_export.cpp

@@ -38,8 +38,11 @@
 #include "blockchain_db/db_types.h"
 #include "version.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "bcutil"
+
 namespace po = boost::program_options;
-using namespace epee; // log_space
+using namespace epee;
 
 std::string join_set_strings(const std::unordered_set<std::string>& db_types_all, const char* delim)
 {
@@ -122,10 +125,8 @@ int main(int argc, char* argv[])
   log_level    = command_line::get_arg(vm, arg_log_level);
   block_stop = command_line::get_arg(vm, arg_block_stop);
 
-  log_space::get_set_log_detalisation_level(true, log_level);
+  mlog_configure("", true);
-  log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL);
   LOG_PRINT_L0("Starting...");
-  LOG_PRINT_L0("Setting log level = " << log_level);
 
   bool opt_testnet = command_line::get_arg(vm, arg_testnet_on);
   bool opt_blocks_dat = command_line::get_arg(vm, arg_blocks_dat);

src/blockchain_utilities/blockchain_import.cpp

@@ -44,6 +44,9 @@
 
 #include "fake_core.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "bcutil"
+
 namespace
 {
 // CONFIG
@@ -132,7 +135,7 @@ int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int&
 #if !defined(BERKELEY_DB)
   if (db_type == "berkeley")
   {
-    LOG_ERROR("BerkeleyDB support disabled.");
+    MFATAL("BerkeleyDB support disabled.");
     return false;
   }
 #endif
@@ -163,7 +166,7 @@ int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int&
 	continue;
       if (db_type == "lmdb")
       {
-	LOG_PRINT_L1("LMDB flag: " << it);
+	MINFO("LMDB flag: " << it);
 	if (it == "nosync")
 	  db_flags |= MDB_NOSYNC;
 	else if (it == "nometasync")
@@ -211,7 +214,7 @@ int pop_blocks(FakeCore& simple_core, int num_blocks)
     if (simple_core.support_batch)
       use_batch = true;
     else
-      LOG_PRINT_L0("WARNING: batch transactions enabled but unsupported or unnecessary for this database type - ignoring");
+      MWARNING("WARNING: batch transactions enabled but unsupported or unnecessary for this database type - ignoring");
   }
 
   if (use_batch)
@@ -260,14 +263,14 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
   boost::system::error_code ec;
   if (!boost::filesystem::exists(fs_import_file_path, ec))
   {
-    LOG_PRINT_L0("bootstrap file not found: " << fs_import_file_path);
+    MFATAL("bootstrap file not found: " << fs_import_file_path);
     return false;
   }
 
   BootstrapFile bootstrap;
   // BootstrapFile bootstrap(import_file_path);
   uint64_t total_source_blocks = bootstrap.count_blocks(import_file_path);
-  LOG_PRINT_L0("bootstrap file last block number: " << total_source_blocks-1 << " (zero-based height)  total blocks: " << total_source_blocks);
+  MINFO("bootstrap file last block number: " << total_source_blocks-1 << " (zero-based height)  total blocks: " << total_source_blocks);
 
   std::cout << ENDL;
   std::cout << "Preparing to read blocks..." << ENDL;
@@ -280,7 +283,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
   uint64_t num_imported = 0;
   if (import_file.fail())
   {
-    LOG_PRINT_L0("import_file.open() fail");
+    MFATAL("import_file.open() fail");
     return false;
   }
 
@@ -309,7 +312,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
 
   // These are what we'll try to use, and they don't have to be a determination
   // from source and destination blockchains, but those are the defaults.
-  LOG_PRINT_L0("start block: " << start_height << "  stop block: " <<
+  MINFO("start block: " << start_height << "  stop block: " <<
       block_stop);
 
   bool use_batch = false;
@@ -318,13 +321,13 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
     if (simple_core.support_batch)
       use_batch = true;
     else
-      LOG_PRINT_L0("WARNING: batch transactions enabled but unsupported or unnecessary for this database type - ignoring");
+      MWARNING("WARNING: batch transactions enabled but unsupported or unnecessary for this database type - ignoring");
   }
 
   if (use_batch)
     simple_core.batch_start(db_batch_size);
 
-  LOG_PRINT_L0("Reading blockchain from bootstrap file...");
+  MINFO("Reading blockchain from bootstrap file...");
   std::cout << ENDL;
 
   // Within the loop, we skip to start_height before we start adding.
@@ -338,7 +341,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
     // TODO: bootstrap.read_chunk();
     if (! import_file) {
       std::cout << refresh_string;
-      LOG_PRINT_L0("End of file reached");
+      MINFO("End of file reached");
       quit = 1;
       break;
     }
@@ -349,29 +352,29 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
     {
       throw std::runtime_error("Error in deserialization of chunk size");
     }
-    LOG_PRINT_L3("chunk_size: " << chunk_size);
+    MDEBUG("chunk_size: " << chunk_size);
 
     if (chunk_size > BUFFER_SIZE)
     {
-      LOG_PRINT_L0("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE);
+      MWARNING("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE);
       throw std::runtime_error("Aborting: chunk size exceeds buffer size");
     }
     if (chunk_size > 100000)
     {
-      LOG_PRINT_L0("NOTE: chunk_size " << chunk_size << " > 100000");
+      MINFO("NOTE: chunk_size " << chunk_size << " > 100000");
     }
     else if (chunk_size == 0) {
-      LOG_PRINT_L0("ERROR: chunk_size == 0");
+      MFATAL("ERROR: chunk_size == 0");
       return 2;
     }
     import_file.read(buffer_block, chunk_size);
     if (! import_file) {
-      LOG_PRINT_L0("ERROR: unexpected end of file: bytes read before error: "
+      MFATAL("ERROR: unexpected end of file: bytes read before error: "
           << import_file.gcount() << " of chunk_size " << chunk_size);
       return 2;
     }
     bytes_read += chunk_size;
-    LOG_PRINT_L3("Total bytes read: " << bytes_read);
+    MINFO("Total bytes read: " << bytes_read);
 
     if (h + NUM_BLOCKS_PER_CHUNK < start_height + 1)
     {
@@ -384,7 +387,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
         << " / " << block_stop
         << std::flush;
       std::cout << ENDL << ENDL;
-      LOG_PRINT_L0("Specified block number reached - stopping.  block: " << h-1 << "  total blocks: " << h);
+      MINFO("Specified block number reached - stopping.  block: " << h-1 << "  total blocks: " << h);
       quit = 1;
       break;
     }
@@ -405,14 +408,14 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
         if ((h-1) % display_interval == 0)
         {
           std::cout << refresh_string;
-          LOG_PRINT_L0("loading block number " << h-1);
+          MDEBUG("loading block number " << h-1);
         }
         else
         {
-          LOG_PRINT_L3("loading block number " << h-1);
+          MDEBUG("loading block number " << h-1);
         }
         b = bp.block;
-        LOG_PRINT_L2("block prev_id: " << b.prev_id << ENDL);
+        MDEBUG("block prev_id: " << b.prev_id << ENDL);
 
         if ((h-1) % progress_interval == 0)
         {
@@ -427,12 +430,12 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
         archived_txs = bp.txs;
 
         // std::cout << refresh_string;
-        // LOG_PRINT_L1("txs: " << archived_txs.size());
+        // MDEBUG("txs: " << archived_txs.size());
 
         // if archived_txs is invalid
         // {
         //   std::cout << refresh_string;
-        //   LOG_PRINT_RED_L0("exception while de-archiving txs, height=" << h);
+        //   MFATAL("exception while de-archiving txs, height=" << h);
         //   quit = 1;
         //   break;
         // }
@@ -445,20 +448,20 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
           ++tx_num;
           // if tx is invalid
           // {
-          //   LOG_PRINT_RED_L0("exception while indexing tx from txs, height=" << h <<", tx_num=" << tx_num);
+          //   MFATAL("exception while indexing tx from txs, height=" << h <<", tx_num=" << tx_num);
           //   quit = 1;
           //   break;
           // }
 
           // std::cout << refresh_string;
-          // LOG_PRINT_L1("tx hash: " << get_transaction_hash(tx));
+          // MDEBUG("tx hash: " << get_transaction_hash(tx));
 
           // crypto::hash hsh = null_hash;
           // size_t blob_size = 0;
           // NOTE: all tx hashes except for coinbase tx are available in the block data
           // get_transaction_hash(tx, hsh, blob_size);
-          // LOG_PRINT_L0("tx " << tx_num << "  " << hsh << " : " << ENDL);
+          // MDEBUG("tx " << tx_num << "  " << hsh << " : " << ENDL);
-          // LOG_PRINT_L0(obj_to_json_str(tx) << ENDL);
+          // MDEBUG(obj_to_json_str(tx) << ENDL);
 
           // add blocks with verification.
           // for Blockchain and blockchain_storage add_new_block().
@@ -475,7 +478,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
             r = simple_core.m_pool.add_tx(tx, tvc, true, true, false, version);
             if (!r)
             {
-              LOG_PRINT_RED_L0("failed to add transaction to transaction pool, height=" << h <<", tx_num=" << tx_num);
+              MFATAL("failed to add transaction to transaction pool, height=" << h <<", tx_num=" << tx_num);
               quit = 1;
               break;
             }
@@ -499,8 +502,8 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
 
           if (bvc.m_verifivation_failed)
           {
-            LOG_PRINT_L0("Failed to add block to blockchain, verification failed, height = " << h);
+            MFATAL("Failed to add block to blockchain, verification failed, height = " << h);
-            LOG_PRINT_L0("skipping rest of file");
+            MFATAL("skipping rest of file");
             // ok to commit previously batched data because it failed only in
             // verification of potential new block with nothing added to batch
             // yet
@@ -509,8 +512,8 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
           }
           if (! bvc.m_added_to_main_chain)
           {
-            LOG_PRINT_L0("Failed to add block to blockchain, height = " << h);
+            MFATAL("Failed to add block to blockchain, height = " << h);
-            LOG_PRINT_L0("skipping rest of file");
+            MFATAL("skipping rest of file");
             // make sure we don't commit partial block data
             quit = 2;
             break;
@@ -527,9 +530,9 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
           coins_generated = bp.coins_generated;
 
           // std::cout << refresh_string;
-          // LOG_PRINT_L2("block_size: " << block_size);
+          // MDEBUG("block_size: " << block_size);
-          // LOG_PRINT_L2("cumulative_difficulty: " << cumulative_difficulty);
+          // MDEBUG("cumulative_difficulty: " << cumulative_difficulty);
-          // LOG_PRINT_L2("coins_generated: " << coins_generated);
+          // MDEBUG("coins_generated: " << coins_generated);
 
           try
           {
@@ -538,7 +541,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
           catch (const std::exception& e)
           {
             std::cout << refresh_string;
-            LOG_PRINT_RED_L0("Error adding block to blockchain: " << e.what());
+            MFATAL("Error adding block to blockchain: " << e.what());
             quit = 2; // make sure we don't commit partial block data
             break;
           }
@@ -563,7 +566,7 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
     catch (const std::exception& e)
     {
       std::cout << refresh_string;
-      LOG_PRINT_RED_L0("exception while reading from file, height=" << h << ": " << e.what());
+      MFATAL("exception while reading from file, height=" << h << ": " << e.what());
       return 2;
     }
   } // while
@@ -582,10 +585,10 @@ int import_from_file(FakeCore& simple_core, const std::string& import_file_path,
       simple_core.batch_stop();
     }
     simple_core.m_storage.get_db().show_stats();
-    LOG_PRINT_L0("Number of blocks imported: " << num_imported);
+    MINFO("Number of blocks imported: " << num_imported);
     if (h > 0)
       // TODO: if there was an error, the last added block is probably at zero-based height h-2
-      LOG_PRINT_L0("Finished at block: " << h-1 << "  total blocks: " << h);
+      MINFO("Finished at block: " << h-1 << "  total blocks: " << h);
   }
   std::cout << ENDL;
   return 0;
@@ -602,7 +605,7 @@ int main(int argc, char* argv[])
   std::string available_dbs = join_set_strings(db_types_all, ", ");
   available_dbs = "available: " + available_dbs;
 
-  uint32_t log_level = LOG_LEVEL_0;
+  uint32_t log_level = 0;
   uint64_t num_blocks = 0;
   uint64_t block_stop = 0;
   std::string m_config_folder;
@@ -719,10 +722,8 @@ int main(int argc, char* argv[])
   m_config_folder = command_line::get_arg(vm, data_dir_arg);
   db_arg_str = command_line::get_arg(vm, arg_database);
 
-  log_space::get_set_log_detalisation_level(true, log_level);
+  mlog_configure("", true);
-  log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL);
+  MINFO("Starting...");
-  LOG_PRINT_L0("Starting...");
-  LOG_PRINT_L0("Setting log level = " << log_level);
 
   boost::filesystem::path fs_import_file_path;
 
@@ -767,23 +768,23 @@ int main(int argc, char* argv[])
     db_engine_compiled = "memory";
   }
 
-  LOG_PRINT_L0("database: " << db_type);
+  MINFO("database: " << db_type);
-  LOG_PRINT_L0("database flags: " << db_flags);
+  MINFO("database flags: " << db_flags);
-  LOG_PRINT_L0("verify:  " << std::boolalpha << opt_verify << std::noboolalpha);
+  MINFO("verify:  " << std::boolalpha << opt_verify << std::noboolalpha);
   if (opt_batch)
   {
-    LOG_PRINT_L0("batch:   " << std::boolalpha << opt_batch << std::noboolalpha
+    MINFO("batch:   " << std::boolalpha << opt_batch << std::noboolalpha
         << "  batch size: " << db_batch_size);
   }
   else
   {
-    LOG_PRINT_L0("batch:   " << std::boolalpha << opt_batch << std::noboolalpha);
+    MINFO("batch:   " << std::boolalpha << opt_batch << std::noboolalpha);
   }
-  LOG_PRINT_L0("resume:  " << std::boolalpha << opt_resume  << std::noboolalpha);
+  MINFO("resume:  " << std::boolalpha << opt_resume  << std::noboolalpha);
-  LOG_PRINT_L0("testnet: " << std::boolalpha << opt_testnet << std::noboolalpha);
+  MINFO("testnet: " << std::boolalpha << opt_testnet << std::noboolalpha);
 
-  LOG_PRINT_L0("bootstrap file path: " << import_file_path);
+  MINFO("bootstrap file path: " << import_file_path);
-  LOG_PRINT_L0("database path:       " << m_config_folder);
+  MINFO("database path:       " << m_config_folder);
 
   try
   {
@@ -813,15 +814,15 @@ int main(int argc, char* argv[])
   if (! vm["pop-blocks"].defaulted())
   {
     num_blocks = command_line::get_arg(vm, arg_pop_blocks);
-    LOG_PRINT_L0("height: " << simple_core.m_storage.get_current_blockchain_height());
+    MINFO("height: " << simple_core.m_storage.get_current_blockchain_height());
     pop_blocks(simple_core, num_blocks);
-    LOG_PRINT_L0("height: " << simple_core.m_storage.get_current_blockchain_height());
+    MINFO("height: " << simple_core.m_storage.get_current_blockchain_height());
     return 0;
   }
 
   if (! vm["drop-hard-fork"].defaulted())
   {
-    LOG_PRINT_L0("Dropping hard fork tables...");
+    MINFO("Dropping hard fork tables...");
     simple_core.m_storage.get_db().drop_hard_fork_info();
     return 0;
   }

src/blockchain_utilities/blocksdat_file.cpp

@@ -28,6 +28,8 @@
 
 #include "blocksdat_file.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "bcutil"
 
 namespace po = boost::program_options;
 
@@ -50,7 +52,7 @@ bool BlocksdatFile::open_writer(const boost::filesystem::path& file_path, uint64
     {
       if (!boost::filesystem::is_directory(dir_path))
       {
-        LOG_PRINT_RED_L0("export directory path is a file: " << dir_path);
+        MFATAL("export directory path is a file: " << dir_path);
         return false;
       }
     }
@@ -58,7 +60,7 @@ bool BlocksdatFile::open_writer(const boost::filesystem::path& file_path, uint64
     {
       if (!boost::filesystem::create_directory(dir_path))
       {
-        LOG_PRINT_RED_L0("Failed to create directory " << dir_path);
+        MFATAL("Failed to create directory " << dir_path);
         return false;
       }
     }
@@ -66,7 +68,7 @@ bool BlocksdatFile::open_writer(const boost::filesystem::path& file_path, uint64
 
   m_raw_data_file = new std::ofstream();
 
-  LOG_PRINT_L0("creating file");
+  MINFO("creating file");
 
   m_raw_data_file->open(file_path.string(), std::ios_base::binary | std::ios_base::out | std::ios::trunc);
   if (m_raw_data_file->fail())
@@ -123,21 +125,21 @@ bool BlocksdatFile::store_blockchain_raw(Blockchain* _blockchain_storage, tx_mem
 
   uint64_t block_start = 0;
   uint64_t block_stop = 0;
-  LOG_PRINT_L0("source blockchain height: " <<  m_blockchain_storage->get_current_blockchain_height()-1);
+  MINFO("source blockchain height: " <<  m_blockchain_storage->get_current_blockchain_height()-1);
   if ((requested_block_stop > 0) && (requested_block_stop < m_blockchain_storage->get_current_blockchain_height()))
   {
-    LOG_PRINT_L0("Using requested block height: " << requested_block_stop);
+    MINFO("Using requested block height: " << requested_block_stop);
     block_stop = requested_block_stop;
   }
   else
   {
     block_stop = m_blockchain_storage->get_current_blockchain_height() - 1;
-    LOG_PRINT_L0("Using block height of source blockchain: " << block_stop);
+    MINFO("Using block height of source blockchain: " << block_stop);
   }
-  LOG_PRINT_L0("Storing blocks raw data...");
+  MINFO("Storing blocks raw data...");
   if (!BlocksdatFile::open_writer(output_file, block_stop))
   {
-    LOG_PRINT_RED_L0("failed to open raw file for write");
+    MFATAL("failed to open raw file for write");
     return false;
   }
   for (m_cur_height = block_start; m_cur_height <= block_stop; ++m_cur_height)
@@ -157,7 +159,7 @@ bool BlocksdatFile::store_blockchain_raw(Blockchain* _blockchain_storage, tx_mem
   std::cout << refresh_string;
   std::cout << "block " << m_cur_height-1 << "/" << block_stop << ENDL;
 
-  LOG_PRINT_L0("Number of blocks exported: " << num_blocks_written);
+  MINFO("Number of blocks exported: " << num_blocks_written);
 
   return BlocksdatFile::close();
 }

src/blockchain_utilities/bootstrap_file.cpp

@@ -32,6 +32,8 @@
 
 #include "bootstrap_file.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "bcutil"
 
 namespace po = boost::program_options;
 
@@ -59,7 +61,7 @@ bool BootstrapFile::open_writer(const boost::filesystem::path& file_path)
     {
       if (!boost::filesystem::is_directory(dir_path))
       {
-        LOG_PRINT_RED_L0("export directory path is a file: " << dir_path);
+        MFATAL("export directory path is a file: " << dir_path);
         return false;
       }
     }
@@ -67,7 +69,7 @@ bool BootstrapFile::open_writer(const boost::filesystem::path& file_path)
     {
       if (!boost::filesystem::create_directory(dir_path))
       {
-        LOG_PRINT_RED_L0("Failed to create directory " << dir_path);
+        MFATAL("Failed to create directory " << dir_path);
         return false;
       }
     }
@@ -80,14 +82,14 @@ bool BootstrapFile::open_writer(const boost::filesystem::path& file_path)
 
   if (! boost::filesystem::exists(file_path))
   {
-    LOG_PRINT_L0("creating file");
+    MDEBUG("creating file");
     do_initialize_file = true;
     num_blocks = 0;
   }
   else
   {
     num_blocks = count_blocks(file_path.string());
-    LOG_PRINT_L0("appending to existing file with height: " << num_blocks-1 << "  total blocks: " << num_blocks);
+    MDEBUG("appending to existing file with height: " << num_blocks-1 << "  total blocks: " << num_blocks);
   }
   m_height = num_blocks;
 
@@ -138,7 +140,7 @@ bool BootstrapFile::initialize_file()
   uint32_t bd_size = 0;
 
   blobdata bd = t_serializable_object_to_blob(bfi);
-  LOG_PRINT_L1("bootstrap::file_info size: " << bd.size());
+  MDEBUG("bootstrap::file_info size: " << bd.size());
   bd_size = bd.size();
 
   if (! ::serialization::dump_binary(bd_size, blob))
@@ -149,7 +151,7 @@ bool BootstrapFile::initialize_file()
   *output_stream_header << bd;
 
   bd = t_serializable_object_to_blob(bbi);
-  LOG_PRINT_L1("bootstrap::blocks_info size: " << bd.size());
+  MDEBUG("bootstrap::blocks_info size: " << bd.size());
   bd_size = bd.size();
 
   if (! ::serialization::dump_binary(bd_size, blob))
@@ -172,10 +174,10 @@ void BootstrapFile::flush_chunk()
   m_output_stream->flush();
 
   uint32_t chunk_size = m_buffer.size();
-  // LOG_PRINT_L0("chunk_size " << chunk_size);
+  // MTRACE("chunk_size " << chunk_size);
   if (chunk_size > BUFFER_SIZE)
   {
-    LOG_PRINT_L0("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE);
+    MWARNING("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE);
   }
 
   std::string blob;
@@ -196,14 +198,14 @@ void BootstrapFile::flush_chunk()
   long num_chars_written = pos_after - pos_before;
   if (static_cast<unsigned long>(num_chars_written) != chunk_size)
   {
-    LOG_PRINT_RED_L0("Error writing chunk:  height: " << m_cur_height << "  chunk_size: " << chunk_size << "  num chars written: " << num_chars_written);
+    MFATAL("Error writing chunk:  height: " << m_cur_height << "  chunk_size: " << chunk_size << "  num chars written: " << num_chars_written);
     throw std::runtime_error("Error writing chunk");
   }
 
   m_buffer.clear();
   delete m_output_stream;
   m_output_stream = new boost::iostreams::stream<boost::iostreams::back_insert_device<buffer_type>>(m_buffer);
-  LOG_PRINT_L1("flushed chunk:  chunk_size: " << chunk_size);
+  MDEBUG("flushed chunk:  chunk_size: " << chunk_size);
 }
 
 void BootstrapFile::write_block(block& block)
@@ -267,10 +269,10 @@ bool BootstrapFile::store_blockchain_raw(Blockchain* _blockchain_storage, tx_mem
   m_blockchain_storage = _blockchain_storage;
   m_tx_pool = _tx_pool;
   uint64_t progress_interval = 100;
-  LOG_PRINT_L0("Storing blocks raw data...");
+  MINFO("Storing blocks raw data...");
   if (!BootstrapFile::open_writer(output_file))
   {
-    LOG_PRINT_RED_L0("failed to open raw file for write");
+    MFATAL("failed to open raw file for write");
     return false;
   }
   block b;
@@ -280,16 +282,16 @@ bool BootstrapFile::store_blockchain_raw(Blockchain* _blockchain_storage, tx_mem
   // height.
   uint64_t block_start = m_height;
   uint64_t block_stop = 0;
-  LOG_PRINT_L0("source blockchain height: " <<  m_blockchain_storage->get_current_blockchain_height()-1);
+  MINFO("source blockchain height: " <<  m_blockchain_storage->get_current_blockchain_height()-1);
   if ((requested_block_stop > 0) && (requested_block_stop < m_blockchain_storage->get_current_blockchain_height()))
   {
-    LOG_PRINT_L0("Using requested block height: " << requested_block_stop);
+    MINFO("Using requested block height: " << requested_block_stop);
     block_stop = requested_block_stop;
   }
   else
   {
     block_stop = m_blockchain_storage->get_current_blockchain_height() - 1;
-    LOG_PRINT_L0("Using block height of source blockchain: " << block_stop);
+    MINFO("Using block height of source blockchain: " << block_stop);
   }
   for (m_cur_height = block_start; m_cur_height <= block_stop; ++m_cur_height)
   {
@@ -315,9 +317,9 @@ bool BootstrapFile::store_blockchain_raw(Blockchain* _blockchain_storage, tx_mem
   std::cout << refresh_string;
   std::cout << "block " << m_cur_height-1 << "/" << block_stop << ENDL;
 
-  LOG_PRINT_L0("Number of blocks exported: " << num_blocks_written);
+  MINFO("Number of blocks exported: " << num_blocks_written);
   if (num_blocks_written > 0)
-    LOG_PRINT_L0("Largest chunk: " << m_max_chunk << " bytes");
+    MINFO("Largest chunk: " << m_max_chunk << " bytes");
 
   return BootstrapFile::close();
 }
@@ -338,11 +340,11 @@ uint64_t BootstrapFile::seek_to_first_chunk(std::ifstream& import_file)
 
   if (file_magic != blockchain_raw_magic)
   {
-    LOG_PRINT_RED_L0("bootstrap file not recognized");
+    MFATAL("bootstrap file not recognized");
     throw std::runtime_error("Aborting");
   }
   else
-    LOG_PRINT_L0("bootstrap file recognized");
+    MINFO("bootstrap file recognized");
 
   uint32_t buflen_file_info;
 
@@ -352,7 +354,7 @@ uint64_t BootstrapFile::seek_to_first_chunk(std::ifstream& import_file)
     throw std::runtime_error("Error reading expected number of bytes");
   if (! ::serialization::parse_binary(str1, buflen_file_info))
     throw std::runtime_error("Error in deserialization of buflen_file_info");
-  LOG_PRINT_L1("bootstrap::file_info size: " << buflen_file_info);
+  MINFO("bootstrap::file_info size: " << buflen_file_info);
 
   if (buflen_file_info > sizeof(buf1))
     throw std::runtime_error("Error: bootstrap::file_info size exceeds buffer size");
@@ -363,9 +365,9 @@ uint64_t BootstrapFile::seek_to_first_chunk(std::ifstream& import_file)
   bootstrap::file_info bfi;
   if (! ::serialization::parse_binary(str1, bfi))
     throw std::runtime_error("Error in deserialization of bootstrap::file_info");
-  LOG_PRINT_L0("bootstrap file v" << unsigned(bfi.major_version) << "." << unsigned(bfi.minor_version));
+  MINFO("bootstrap file v" << unsigned(bfi.major_version) << "." << unsigned(bfi.minor_version));
-  LOG_PRINT_L0("bootstrap magic size: " << sizeof(file_magic));
+  MINFO("bootstrap magic size: " << sizeof(file_magic));
-  LOG_PRINT_L0("bootstrap header size: " << bfi.header_size);
+  MINFO("bootstrap header size: " << bfi.header_size);
 
   uint64_t full_header_size = sizeof(file_magic) + bfi.header_size;
   import_file.seekg(full_header_size);
@@ -379,7 +381,7 @@ uint64_t BootstrapFile::count_blocks(const std::string& import_file_path)
   boost::system::error_code ec;
   if (!boost::filesystem::exists(raw_file_path, ec))
   {
-    LOG_PRINT_L0("bootstrap file not found: " << raw_file_path);
+    MFATAL("bootstrap file not found: " << raw_file_path);
     throw std::runtime_error("Aborting");
   }
   std::ifstream import_file;
@@ -388,14 +390,14 @@ uint64_t BootstrapFile::count_blocks(const std::string& import_file_path)
   uint64_t h = 0;
   if (import_file.fail())
   {
-    LOG_PRINT_L0("import_file.open() fail");
+    MFATAL("import_file.open() fail");
     throw std::runtime_error("Aborting");
   }
 
   uint64_t full_header_size; // 4 byte magic + length of header structures
   full_header_size = seek_to_first_chunk(import_file);
 
-  LOG_PRINT_L0("Scanning blockchain from bootstrap file...");
+  MINFO("Scanning blockchain from bootstrap file...");
   block b;
   bool quit = false;
   uint64_t bytes_read = 0;
@@ -409,7 +411,7 @@ uint64_t BootstrapFile::count_blocks(const std::string& import_file_path)
     import_file.read(buf1, sizeof(chunk_size));
     if (!import_file) {
       std::cout << refresh_string;
-      LOG_PRINT_L1("End of file reached");
+      MDEBUG("End of file reached");
       quit = true;
       break;
     }
@@ -425,38 +427,38 @@ uint64_t BootstrapFile::count_blocks(const std::string& import_file_path)
     str1.assign(buf1, sizeof(chunk_size));
     if (! ::serialization::parse_binary(str1, chunk_size))
       throw std::runtime_error("Error in deserialization of chunk_size");
-    LOG_PRINT_L3("chunk_size: " << chunk_size);
+    MDEBUG("chunk_size: " << chunk_size);
 
     if (chunk_size > BUFFER_SIZE)
     {
       std::cout << refresh_string;
-      LOG_PRINT_L0("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE
+      MWARNING("WARNING: chunk_size " << chunk_size << " > BUFFER_SIZE " << BUFFER_SIZE
           << "  height: " << h-1);
       throw std::runtime_error("Aborting: chunk size exceeds buffer size");
     }
     if (chunk_size > 100000)
     {
       std::cout << refresh_string;
-      LOG_PRINT_L0("NOTE: chunk_size " << chunk_size << " > 100000" << "  height: "
+      MDEBUG("NOTE: chunk_size " << chunk_size << " > 100000" << "  height: "
           << h-1);
     }
     else if (chunk_size <= 0) {
       std::cout << refresh_string;
-      LOG_PRINT_L0("ERROR: chunk_size " << chunk_size << " <= 0" << "  height: " << h-1);
+      MDEBUG("ERROR: chunk_size " << chunk_size << " <= 0" << "  height: " << h-1);
       throw std::runtime_error("Aborting");
     }
     // skip to next expected block size value
     import_file.seekg(chunk_size, std::ios_base::cur);
     if (! import_file) {
       std::cout << refresh_string;
-      LOG_PRINT_L0("ERROR: unexpected end of file: bytes read before error: "
+      MFATAL("ERROR: unexpected end of file: bytes read before error: "
           << import_file.gcount() << " of chunk_size " << chunk_size);
       throw std::runtime_error("Aborting");
     }
     bytes_read += chunk_size;
 
     // std::cout << refresh_string;
-    LOG_PRINT_L3("Number bytes scanned: " << bytes_read);
+    MINFO("Number bytes scanned: " << bytes_read);
   }
 
   import_file.close();

src/blockchain_utilities/cn_deserialize.cpp

@@ -33,8 +33,11 @@
 #include "common/command_line.h"
 #include "version.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "bcutil"
+
 namespace po = boost::program_options;
-using namespace epee; // log_space
+using namespace epee;
 
 using namespace cryptonote;
 
@@ -87,8 +90,7 @@ int main(int argc, char* argv[])
     return 1;
   }
 
-  log_space::get_set_log_detalisation_level(true, log_level);
+  mlog_configure("", true);
-  log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL);
 
   std::string m_config_folder;
 

src/common/dns_utils.cpp

@@ -41,6 +41,9 @@
 using namespace epee;
 namespace bf = boost::filesystem;
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.dns"
+
 static boost::mutex instance_lock;
 
 namespace

src/common/i18n.cpp

@@ -36,6 +36,9 @@
 #include "common/util.h"
 #include "common/i18n.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "i18n"
+
 static const unsigned char qm_magic[16] = {0x3c, 0xb8, 0x64, 0x18, 0xca, 0xef, 0x9c, 0x95, 0xcd, 0x21, 0x1c, 0xbf, 0x60, 0xa1, 0xbd, 0xdd};
 
 static std::map<std::string,std::string> i18n_entries;

src/common/perf_timer.cpp

@@ -28,18 +28,22 @@
 
 #include "perf_timer.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "perf"
+
 namespace tools
 {
 
-int performance_timer_log_level = 2;
+el::Level performance_timer_log_level = el::Level::Debug;
 __thread std::vector<PerformanceTimer*> *performance_timers = NULL;
 
-void set_performance_timer_log_level(int level)
+void set_performance_timer_log_level(el::Level level)
 {
-  if (level < LOG_LEVEL_MIN || level > LOG_LEVEL_MAX)
+  if (level != el::Level::Debug && level != el::Level::Trace && level != el::Level::Info
+   && level != el::Level::Warning && level != el::Level::Error && level != el::Level::Fatal)
   {
-    LOG_PRINT_L0("Wrong log level: " << level << ", using 2");
+    MERROR("Wrong log level: " << el::LevelHelper::convertToString(level) << ", using Debug");
-    level = 2;
+    level = el::Level::Debug;
   }
   performance_timer_log_level = level;
 }

src/common/perf_timer.h

@@ -32,23 +32,26 @@
 #include <stdio.h>
 #include "misc_log_ex.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "perf"
+
 namespace tools
 {
 
 class PerformanceTimer;
 
-extern int performance_timer_log_level;
+extern el::Level performance_timer_log_level;
 extern __thread std::vector<PerformanceTimer*> *performance_timers;
 
 class PerformanceTimer
 {
 public:
-  PerformanceTimer(const std::string &s, int l = LOG_LEVEL_2): name(s), level(l), started(false)
+  PerformanceTimer(const std::string &s, el::Level l = el::Level::Debug): name(s), level(l), started(false)
   {
     ticks = epee::misc_utils::get_tick_count();
     if (!performance_timers)
     {
-      LOG_PRINT("PERF             ----------", level);
+      MLOG(level, "PERF             ----------");
       performance_timers = new std::vector<PerformanceTimer*>();
     }
     else
@@ -56,7 +59,7 @@ public:
       PerformanceTimer *pt = performance_timers->back();
       if (!pt->started)
       {
-        LOG_PRINT("PERF           " << std::string((performance_timers->size()-1) * 2, ' ') << "  " << pt->name, pt->level);
+        MLOG(pt->level, "PERF           " << std::string((performance_timers->size()-1) * 2, ' ') << "  " << pt->name);
         pt->started = true;
       }
     }
@@ -69,7 +72,7 @@ public:
     ticks = epee::misc_utils::get_tick_count() - ticks;
     char s[12];
     snprintf(s, sizeof(s), "%8llu  ", (unsigned long long)ticks);
-    LOG_PRINT("PERF " << s << std::string(performance_timers->size() * 2, ' ') << "  " << name, level);
+    MLOG(level, "PERF " << s << std::string(performance_timers->size() * 2, ' ') << "  " << name);
     if (performance_timers->empty())
     {
       delete performance_timers;
@@ -79,12 +82,12 @@ public:
 
 private:
   std::string name;
-  int level;
+  el::Level level;
   uint64_t ticks;
   bool started;
 };
 
-void set_performance_timer_log_level(int level);
+void set_performance_timer_log_level(el::Level level);
 
 #define PERF_TIMER(name) tools::PerformanceTimer pt_##name(#name, tools::performance_timer_log_level)
 #define PERF_TIMER_L(name, l) tools::PerformanceTimer pt_##name(#name, l)

src/common/scoped_message_writer.h

@@ -34,20 +34,23 @@
 namespace tools
 {
 
+/************************************************************************/
+/*                                                                      */
+/************************************************************************/
 class scoped_message_writer
 {
 private:
   bool m_flush;
   std::stringstream m_oss;
-  epee::log_space::console_colors m_color;
+  epee::console_colors m_color;
   bool m_bright;
-  int m_log_level;
+  el::Level m_log_level;
 public:
   scoped_message_writer(
-      epee::log_space::console_colors color = epee::log_space::console_color_default
+      epee::console_colors color = epee::console_color_default
     , bool bright = false
     , std::string&& prefix = std::string()
-    , int log_level = LOG_LEVEL_2
+    , el::Level log_level = el::Level::Info
     )
     : m_flush(true)
     , m_color(color)
@@ -88,17 +91,17 @@ public:
     {
       m_flush = false;
 
-      LOG_PRINT(m_oss.str(), m_log_level);
+      MCLOG(m_log_level, "msgwriter", m_oss.str());
 
-      if (epee::log_space::console_color_default == m_color)
+      if (epee::console_color_default == m_color)
       {
         std::cout << m_oss.str();
       }
       else
       {
-        epee::log_space::set_console_color(m_color, m_bright);
+        set_console_color(m_color, m_bright);
         std::cout << m_oss.str();
-        epee::log_space::reset_console_color();
+        epee::reset_console_color();
       }
       std::cout << std::endl;
     }
@@ -107,17 +110,17 @@ public:
 
 inline scoped_message_writer success_msg_writer()
 {
-  return scoped_message_writer(epee::log_space::console_color_green, false, std::string(), LOG_LEVEL_2);
+  return scoped_message_writer(epee::console_color_green, false, std::string(), el::Level::Info);
 }
 
-inline scoped_message_writer msg_writer(epee::log_space::console_colors color = epee::log_space::console_color_default)
+inline scoped_message_writer msg_writer(epee::console_colors color = epee::console_color_default)
 {
-  return scoped_message_writer(color, false, std::string(), LOG_LEVEL_2);
+  return scoped_message_writer(color, false, std::string(), el::Level::Info);
 }
 
 inline scoped_message_writer fail_msg_writer()
 {
-  return scoped_message_writer(epee::log_space::console_color_red, true, "Error: ", LOG_LEVEL_0);
+  return scoped_message_writer(epee::console_color_red, true, "Error: ", el::Level::Error);
 }
 
 } // namespace tools

src/common/stack_trace.cpp

@@ -35,6 +35,11 @@
 #include <dlfcn.h>
 #endif
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "stacktrace"
+
+#define ST_LOG(x) CERROR(el::base::Writer,el::base::DispatchAction::FileOnlyLog,MONERO_DEFAULT_LOG_CATEGORY) << x
+
 // from http://stackoverflow.com/questions/11665829/how-can-i-print-stack-trace-for-caught-exceptions-in-c-code-injection-in-c
 
 // The decl of __cxa_throw in /usr/include/.../cxxabi.h uses
@@ -103,34 +108,34 @@ void log_stack_trace(const char *msg)
   const char *log = stack_trace_log.empty() ? NULL : stack_trace_log.c_str();
 
   if (msg)
-    LOG_PRINT2(log, msg, LOG_LEVEL_0);
+    ST_LOG(msg);
-  LOG_PRINT2(log, "Unwound call stack:", LOG_LEVEL_0);
+  ST_LOG("Unwound call stack:");
   if (unw_getcontext(&ctx) < 0) {
-    LOG_PRINT2(log, "Failed to create unwind context", LOG_LEVEL_0);
+    ST_LOG("Failed to create unwind context");
     return;
   }
   if (unw_init_local(&cur, &ctx) < 0) {
-    LOG_PRINT2(log, "Failed to find the first unwind frame", LOG_LEVEL_0);
+    ST_LOG("Failed to find the first unwind frame");
     return;
   }
   for (level = 1; level < 999; ++level) { // 999 for safety
     int ret = unw_step(&cur);
     if (ret < 0) {
-      LOG_PRINT2(log, "Failed to find the next frame", LOG_LEVEL_0);
+      ST_LOG("Failed to find the next frame");
       return;
     }
     if (ret == 0)
       break;
     if (unw_get_reg(&cur, UNW_REG_IP, &ip) < 0) {
-      LOG_PRINT2(log, "  " << std::setw(4) << level, LOG_LEVEL_0);
+      ST_LOG("  " << std::setw(4) << level);
       continue;
     }
     if (unw_get_proc_name(&cur, sym, sizeof(sym), &off) < 0) {
-      LOG_PRINT2(log, "  " << std::setw(4) << level << std::setbase(16) << std::setw(20) << "0x" << ip, LOG_LEVEL_0);
+      ST_LOG("  " << std::setw(4) << level << std::setbase(16) << std::setw(20) << "0x" << ip);
       continue;
     }
     dsym = abi::__cxa_demangle(sym, NULL, NULL, &status);
-    LOG_PRINT2(log, "  " << std::setw(4) << level << std::setbase(16) << std::setw(20) << "0x" << ip << " " << (!status && dsym ? dsym : sym) << " + " << "0x" << off, LOG_LEVEL_0);
+    ST_LOG("  " << std::setw(4) << level << std::setbase(16) << std::setw(20) << "0x" << ip << " " << (!status && dsym ? dsym : sym) << " + " << "0x" << off);
     free(dsym);
   }
 }

src/common/util.h

@@ -152,7 +152,7 @@ namespace tools
       }
       else
       {
-        LOG_PRINT_RED_L0("Got control signal " << type << ". Exiting without saving...");
+        MGINFO_RED("Got control signal " << type << ". Exiting without saving...");
         return FALSE;
       }
       return TRUE;

src/cryptonote_core/CMakeLists.txt

@@ -76,7 +76,6 @@ target_link_libraries(cryptonote_core
   PUBLIC
     common
     crypto
-    otshell_utils
     blockchain_db
     ringct
     ${Boost_DATE_TIME_LIBRARY}

src/cryptonote_core/account.cpp

@@ -40,6 +40,10 @@ extern "C"
 }
 #include "cryptonote_core/cryptonote_basic_impl.h"
 #include "cryptonote_core/cryptonote_format_utils.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "account"
+
 using namespace std;
 
 DISABLE_VS_WARNINGS(4244 4345)

src/cryptonote_core/blockchain.cpp

@@ -56,6 +56,9 @@
 #include "blocks/blocks.h"
 #endif
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "blockchain"
+
 //#include "serialization/json_archive.h"
 
 /* TODO:
@@ -71,6 +74,8 @@ extern "C" void slow_hash_free_state();
 
 DISABLE_VS_WARNINGS(4267)
 
+#define MERROR_VER(x) MCERROR("verify", x)
+
 // used to overestimate the block reward when estimating a per kB to use
 #define BLOCK_REWARD_OVERESTIMATE (10 * 1000000000000)
 
@@ -180,7 +185,7 @@ bool Blockchain::scan_outputkeys_for_indexes(size_t tx_version, const txin_to_ke
     }
     catch (...)
     {
-      LOG_PRINT_L0("Output does not exist! amount = " << tx_in_to_key.amount);
+      MERROR_VER("Output does not exist! amount = " << tx_in_to_key.amount);
       return false;
     }
   }
@@ -189,7 +194,7 @@ bool Blockchain::scan_outputkeys_for_indexes(size_t tx_version, const txin_to_ke
     // check for partial results and add the rest if needed;
     if (outputs.size() < absolute_offsets.size() && outputs.size() > 0)
     {
-      LOG_PRINT_L1("Additional outputs needed: " << absolute_offsets.size() - outputs.size());
+      MDEBUG("Additional outputs needed: " << absolute_offsets.size() - outputs.size());
       std::vector < uint64_t > add_offsets;
       std::vector<output_data_t> add_outputs;
       for (size_t i = outputs.size(); i < absolute_offsets.size(); i++)
@@ -200,7 +205,7 @@ bool Blockchain::scan_outputkeys_for_indexes(size_t tx_version, const txin_to_ke
       }
       catch (...)
       {
-        LOG_PRINT_L0("Output does not exist! amount = " << tx_in_to_key.amount);
+        MERROR_VER("Output does not exist! amount = " << tx_in_to_key.amount);
         return false;
       }
       outputs.insert(outputs.end(), add_outputs.begin(), add_outputs.end());
@@ -224,13 +229,13 @@ bool Blockchain::scan_outputkeys_for_indexes(size_t tx_version, const txin_to_ke
         // call to the passed boost visitor to grab the public key for the output
         if (!vis.handle_output(output_index.unlock_time, output_index.pubkey, output_index.commitment))
         {
-          LOG_PRINT_L0("Failed to handle_output for output no = " << count << ", with absolute offset " << i);
+          MERROR_VER("Failed to handle_output for output no = " << count << ", with absolute offset " << i);
           return false;
         }
       }
       catch (...)
       {
-        LOG_PRINT_L0("Output does not exist! amount = " << tx_in_to_key.amount << ", absolute_offset = " << i);
+        MERROR_VER("Output does not exist! amount = " << tx_in_to_key.amount << ", absolute_offset = " << i);
         return false;
       }
 
@@ -248,12 +253,12 @@ bool Blockchain::scan_outputkeys_for_indexes(size_t tx_version, const txin_to_ke
     }
     catch (const OUTPUT_DNE& e)
     {
-      LOG_PRINT_L0("Output does not exist: " << e.what());
+      MERROR_VER("Output does not exist: " << e.what());
       return false;
     }
     catch (const TX_DNE& e)
     {
-      LOG_PRINT_L0("Transaction does not exist: " << e.what());
+      MERROR_VER("Transaction does not exist: " << e.what());
       return false;
     }
 
@@ -326,7 +331,7 @@ bool Blockchain::init(BlockchainDB* db, const bool testnet, const cryptonote::te
   //       taking testnet into account
   if(!m_db->height())
   {
-    LOG_PRINT_L0("Blockchain not loaded, generating genesis block.");
+    MINFO("Blockchain not loaded, generating genesis block.");
     block bl = boost::value_initialized<block>();
     block_verification_context bvc = boost::value_initialized<block_verification_context>();
     if (m_testnet)
@@ -372,7 +377,7 @@ bool Blockchain::init(BlockchainDB* db, const bool testnet, const cryptonote::te
     load_compiled_in_block_hashes();
 #endif
 
-  LOG_PRINT_GREEN("Blockchain initialized. last block: " << m_db->height() - 1 << ", " << epee::misc_utils::get_time_interval_string(timestamp_diff) << " time ago, current difficulty: " << get_difficulty_for_next_block(), LOG_LEVEL_0);
+  MINFO("Blockchain initialized. last block: " << m_db->height() - 1 << ", " << epee::misc_utils::get_time_interval_string(timestamp_diff) << " time ago, current difficulty: " << get_difficulty_for_next_block());
   m_db->block_txn_stop();
 
   update_next_cumulative_size_limit();
@@ -404,18 +409,18 @@ bool Blockchain::store_blockchain()
   }
   catch (const std::exception& e)
   {
-    LOG_PRINT_L0(std::string("Error syncing blockchain db: ") + e.what() + "-- shutting down now to prevent issues!");
+    MERROR(std::string("Error syncing blockchain db: ") + e.what() + "-- shutting down now to prevent issues!");
     throw;
   }
   catch (...)
   {
-    LOG_PRINT_L0("There was an issue storing the blockchain, shutting down now to prevent issues!");
+    MERROR("There was an issue storing the blockchain, shutting down now to prevent issues!");
     throw;
   }
 
   TIME_MEASURE_FINISH(save);
   if(m_show_time_stats)
-    LOG_PRINT_L0("Blockchain stored OK, took: " << save << " ms");
+    MINFO("Blockchain stored OK, took: " << save << " ms");
   return true;
 }
 //------------------------------------------------------------------
@@ -423,7 +428,7 @@ bool Blockchain::deinit()
 {
   LOG_PRINT_L3("Blockchain::" << __func__);
 
-  LOG_PRINT_L1("Stopping blockchain read/write activity");
+  MTRACE("Stopping blockchain read/write activity");
 
  // stop async service
   m_async_work_idle.reset();
@@ -441,7 +446,7 @@ bool Blockchain::deinit()
   try
   {
     m_db->close();
-    LOG_PRINT_L1("Local blockchain read/write activity stopped successfully");
+    MTRACE("Local blockchain read/write activity stopped successfully");
   }
   catch (const std::exception& e)
   {
@@ -620,12 +625,12 @@ crypto::hash Blockchain::get_block_id_by_height(uint64_t height) const
   }
   catch (const std::exception& e)
   {
-    LOG_PRINT_L0(std::string("Something went wrong fetching block hash by height: ") + e.what());
+    MERROR(std::string("Something went wrong fetching block hash by height: ") + e.what());
     throw;
   }
   catch (...)
   {
-    LOG_PRINT_L0(std::string("Something went wrong fetching block hash by height"));
+    MERROR(std::string("Something went wrong fetching block hash by height"));
     throw;
   }
   return null_hash;
@@ -654,12 +659,12 @@ bool Blockchain::get_block_by_hash(const crypto::hash &h, block &blk) const
   }
   catch (const std::exception& e)
   {
-    LOG_PRINT_L0(std::string("Something went wrong fetching block by hash: ") + e.what());
+    MERROR(std::string("Something went wrong fetching block by hash: ") + e.what());
     throw;
   }
   catch (...)
   {
-    LOG_PRINT_L0(std::string("Something went wrong fetching block hash by hash"));
+    MERROR(std::string("Something went wrong fetching block hash by hash"));
     throw;
   }
 
@@ -773,10 +778,10 @@ bool Blockchain::rollback_blockchain_switching(std::list<block>& original_chain,
 
   m_hardfork->reorganize_from_chain_height(rollback_height);
 
-  LOG_PRINT_L1("Rollback to height " << rollback_height << " was successful.");
+  MINFO("Rollback to height " << rollback_height << " was successful.");
   if (original_chain.size())
   {
-    LOG_PRINT_L1("Restoration to previous blockchain successful as well.");
+    MINFO("Restoration to previous blockchain successful as well.");
   }
   return true;
 }
@@ -824,7 +829,7 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::
     // return false
     if(!r || !bvc.m_added_to_main_chain)
     {
-      LOG_PRINT_L1("Failed to switch to alternative blockchain");
+      MERROR("Failed to switch to alternative blockchain");
 
       // rollback_blockchain_switching should be moved to two different
       // functions: rollback and apply_chain, but for now we pretend it is
@@ -835,7 +840,7 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::
       // about them again so we can immediately dismiss them, but needs some
       // looking into.
       add_block_as_invalid(ch_ent->second, get_block_hash(ch_ent->second.bl));
-      LOG_PRINT_L1("The block was inserted as invalid while connecting new alternative chain, block_id: " << get_block_hash(ch_ent->second.bl));
+      MERROR("The block was inserted as invalid while connecting new alternative chain, block_id: " << get_block_hash(ch_ent->second.bl));
       m_alternative_chains.erase(*alt_ch_iter++);
 
       for(auto alt_ch_to_orph_iter = alt_ch_iter; alt_ch_to_orph_iter != alt_chain.end(); )
@@ -857,7 +862,7 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::
       bool r = handle_alternative_block(old_ch_ent, get_block_hash(old_ch_ent), bvc);
       if(!r)
       {
-        LOG_PRINT_L1("Failed to push ex-main chain blocks to alternative chain ");
+        MERROR("Failed to push ex-main chain blocks to alternative chain ");
         // previously this would fail the blockchain switching, but I don't
         // think this is bad enough to warrant that.
       }
@@ -872,7 +877,7 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<blocks_ext_by_hash::
 
   m_hardfork->reorganize_from_chain_height(split_height);
 
-  LOG_PRINT_GREEN("REORGANIZE SUCCESS! on height: " << split_height << ", new blockchain size: " << m_db->height(), LOG_LEVEL_0);
+  MGINFO_GREEN("REORGANIZE SUCCESS! on height: " << split_height << ", new blockchain size: " << m_db->height());
   return true;
 }
 //------------------------------------------------------------------
@@ -953,10 +958,10 @@ bool Blockchain::prevalidate_miner_transaction(const block& b, uint64_t height)
   CHECK_AND_ASSERT_MES(b.miner_tx.vin[0].type() == typeid(txin_gen), false, "coinbase transaction in the block has the wrong type");
   if(boost::get<txin_gen>(b.miner_tx.vin[0]).height != height)
   {
-    LOG_PRINT_RED_L1("The miner transaction in block has invalid height: " << boost::get<txin_gen>(b.miner_tx.vin[0]).height << ", expected: " << height);
+    MWARNING("The miner transaction in block has invalid height: " << boost::get<txin_gen>(b.miner_tx.vin[0]).height << ", expected: " << height);
     return false;
   }
-  LOG_PRINT_L1("Miner tx hash: " << get_transaction_hash(b.miner_tx));
+  MDEBUG("Miner tx hash: " << get_transaction_hash(b.miner_tx));
   CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, false, "coinbase transaction transaction has the wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW);
 
   //check outs overflow
@@ -965,7 +970,7 @@ bool Blockchain::prevalidate_miner_transaction(const block& b, uint64_t height)
   //      does not overflow a uint64_t, and this transaction *is* a uint64_t...
   if(!check_outs_overflow(b.miner_tx))
   {
-    LOG_PRINT_RED_L1("miner transaction has money overflow in block " << get_block_hash(b));
+    MERROR("miner transaction has money overflow in block " << get_block_hash(b));
     return false;
   }
 
@@ -985,7 +990,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
   if (version == 3) {
     for (auto &o: b.miner_tx.vout) {
       if (!is_valid_decomposed_amount(o.amount)) {
-        LOG_PRINT_L1("miner tx output " << print_money(o.amount) << " is not a valid decomposed amount");
+        MERROR_VER("miner tx output " << print_money(o.amount) << " is not a valid decomposed amount");
         return false;
       }
     }
@@ -995,12 +1000,12 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
   get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
   if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward, version))
   {
-    LOG_PRINT_L1("block size " << cumulative_block_size << " is bigger than allowed for this blockchain");
+    MERROR_VER("block size " << cumulative_block_size << " is bigger than allowed for this blockchain");
     return false;
   }
   if(base_reward + fee < money_in_use)
   {
-    LOG_PRINT_L1("coinbase transaction spend too much money (" << print_money(money_in_use) << "). Block reward is " << print_money(base_reward + fee) << "(" << print_money(base_reward) << "+" << print_money(fee) << ")");
+    MERROR_VER("coinbase transaction spend too much money (" << print_money(money_in_use) << "). Block reward is " << print_money(base_reward + fee) << "(" << print_money(base_reward) << "+" << print_money(fee) << ")");
     return false;
   }
   // From hard fork 2, we allow a miner to claim less block reward than is allowed, in case a miner wants less dust
@@ -1008,7 +1013,7 @@ bool Blockchain::validate_miner_transaction(const block& b, size_t cumulative_bl
   {
     if(base_reward + fee != money_in_use)
     {
-      LOG_PRINT_L1("coinbase transaction doesn't use full amount of block reward:  spent: " << money_in_use << ",  block reward " << base_reward + fee << "(" << base_reward << "+" << fee << ")");
+      MDEBUG("coinbase transaction doesn't use full amount of block reward:  spent: " << money_in_use << ",  block reward " << base_reward + fee << "(" << base_reward << "+" << fee << ")");
       return false;
     }
   }
@@ -1139,7 +1144,7 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
     LOG_ERROR("Creating block template: error: wrongly calculated fee");
   }
   CRITICAL_REGION_END();
-  LOG_PRINT_L1("Creating block template: height " << height <<
+  MDEBUG("Creating block template: height " << height <<
       ", median size " << median_size <<
       ", already generated coins " << already_generated_coins <<
       ", transaction size " << txs_size <<
@@ -1157,7 +1162,7 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
   CHECK_AND_ASSERT_MES(r, false, "Failed to construct miner tx, first chance");
   size_t cumulative_size = txs_size + get_object_blobsize(b.miner_tx);
 #if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
-  LOG_PRINT_L1("Creating block template: miner tx size " << get_object_blobsize(b.miner_tx) <<
+  MDEBUG("Creating block template: miner tx size " << get_object_blobsize(b.miner_tx) <<
       ", cumulative size " << cumulative_size);
 #endif
   for (size_t try_count = 0; try_count != 10; ++try_count)
@@ -1170,7 +1175,7 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
     {
       cumulative_size = txs_size + coinbase_blob_size;
 #if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
-      LOG_PRINT_L1("Creating block template: miner tx size " << coinbase_blob_size <<
+      MDEBUG("Creating block template: miner tx size " << coinbase_blob_size <<
           ", cumulative size " << cumulative_size << " is greater then before");
 #endif
       continue;
@@ -1180,7 +1185,7 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
     {
       size_t delta = cumulative_size - txs_size - coinbase_blob_size;
 #if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
-      LOG_PRINT_L1("Creating block template: miner tx size " << coinbase_blob_size <<
+      MDEBUG("Creating block template: miner tx size " << coinbase_blob_size <<
           ", cumulative size " << txs_size + coinbase_blob_size <<
           " is less then before, adding " << delta << " zero bytes");
 #endif
@@ -1193,16 +1198,16 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
         if (cumulative_size != txs_size + get_object_blobsize(b.miner_tx))
         {
           //fuck, not lucky, -1 makes varint-counter size smaller, in that case we continue to grow with cumulative_size
-          LOG_PRINT_RED("Miner tx creation has no luck with delta_extra size = " << delta << " and " << delta - 1 , LOG_LEVEL_2);
+          MDEBUG("Miner tx creation has no luck with delta_extra size = " << delta << " and " << delta - 1);
           cumulative_size += delta - 1;
           continue;
         }
-        LOG_PRINT_GREEN("Setting extra for block: " << b.miner_tx.extra.size() << ", try_count=" << try_count, LOG_LEVEL_1);
+        MDEBUG("Setting extra for block: " << b.miner_tx.extra.size() << ", try_count=" << try_count);
       }
     }
     CHECK_AND_ASSERT_MES(cumulative_size == txs_size + get_object_blobsize(b.miner_tx), false, "unexpected case: cumulative_size=" << cumulative_size << " is not equal txs_cumulative_size=" << txs_size << " + get_object_blobsize(b.miner_tx)=" << get_object_blobsize(b.miner_tx));
 #if defined(DEBUG_CREATE_BLOCK_TEMPLATE)
-    LOG_PRINT_L1("Creating block template: miner tx size " << coinbase_blob_size <<
+    MDEBUG("Creating block template: miner tx size " << coinbase_blob_size <<
         ", cumulative size " << cumulative_size << " is now good");
 #endif
     return true;
@@ -1246,7 +1251,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
   uint64_t block_height = get_block_height(b);
   if(0 == block_height)
   {
-    LOG_PRINT_L1("Block with id: " << epee::string_tools::pod_to_hex(id) << " (as alternative), but miner tx says height is 0.");
+    MERROR_VER("Block with id: " << epee::string_tools::pod_to_hex(id) << " (as alternative), but miner tx says height is 0.");
     bvc.m_verifivation_failed = true;
     return false;
   }
@@ -1256,7 +1261,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
   // the block to be added, then this is fine.
   if (!m_checkpoints.is_alternative_block_allowed(get_current_blockchain_height(), block_height))
   {
-    LOG_PRINT_RED_L1("Block with id: " << id << std::endl << " can't be accepted for alternative chain, block height: " << block_height << std::endl << " blockchain height: " << get_current_blockchain_height());
+    MERROR_VER("Block with id: " << id << std::endl << " can't be accepted for alternative chain, block height: " << block_height << std::endl << " blockchain height: " << get_current_blockchain_height());
     bvc.m_verifivation_failed = true;
     return false;
   }
@@ -1299,7 +1304,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
       // this alternate chain with it.
       if (!m_db->block_exists(alt_chain.front()->second.bl.prev_id))
       {
-        LOG_PRINT_L1("alternate chain does not appear to connect to main chain...");
+        MERROR("alternate chain does not appear to connect to main chain...");
         return false;
       }
 
@@ -1322,7 +1327,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
     // (not earlier than the median of the last X blocks)
     if(!check_block_timestamp(timestamps, b))
     {
-      LOG_PRINT_RED_L1("Block with id: " << id << std::endl << " for alternative chain, has invalid timestamp: " << b.timestamp);
+      MERROR_VER("Block with id: " << id << std::endl << " for alternative chain, has invalid timestamp: " << b.timestamp);
       bvc.m_verifivation_failed = true;
       return false;
     }
@@ -1348,14 +1353,14 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
     get_block_longhash(bei.bl, proof_of_work, bei.height);
     if(!check_hash(proof_of_work, current_diff))
     {
-      LOG_PRINT_RED_L1("Block with id: " << id << std::endl << " for alternative chain, does not have enough proof of work: " << proof_of_work << std::endl << " expected difficulty: " << current_diff);
+      MERROR_VER("Block with id: " << id << std::endl << " for alternative chain, does not have enough proof of work: " << proof_of_work << std::endl << " expected difficulty: " << current_diff);
       bvc.m_verifivation_failed = true;
       return false;
     }
 
     if(!prevalidate_miner_transaction(b, bei.height))
     {
-      LOG_PRINT_RED_L1("Block with id: " << epee::string_tools::pod_to_hex(id) << " (as alternative) has incorrect miner transaction.");
+      MERROR_VER("Block with id: " << epee::string_tools::pod_to_hex(id) << " (as alternative) has incorrect miner transaction.");
       bvc.m_verifivation_failed = true;
       return false;
     }
@@ -1385,7 +1390,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
     if(is_a_checkpoint)
     {
       //do reorganize!
-      LOG_PRINT_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_db->height() - 1 << ", checkpoint is found in alternative chain on height " << bei.height, LOG_LEVEL_0);
+      MGINFO_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_db->height() - 1 << ", checkpoint is found in alternative chain on height " << bei.height);
 
       bool r = switch_to_alternative_blockchain(alt_chain, true);
 
@@ -1397,7 +1402,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
     else if(main_chain_cumulative_difficulty < bei.cumulative_difficulty) //check if difficulty bigger then in main chain
     {
       //do reorganize!
-      LOG_PRINT_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_db->height() - 1 << " with cum_difficulty " << m_db->get_block_cumulative_difficulty(m_db->height() - 1) << std::endl << " alternative blockchain size: " << alt_chain.size() << " with cum_difficulty " << bei.cumulative_difficulty, LOG_LEVEL_0);
+      MGINFO_GREEN("###### REORGANIZE on height: " << alt_chain.front()->second.height << " of " << m_db->height() - 1 << " with cum_difficulty " << m_db->get_block_cumulative_difficulty(m_db->height() - 1) << std::endl << " alternative blockchain size: " << alt_chain.size() << " with cum_difficulty " << bei.cumulative_difficulty);
 
       bool r = switch_to_alternative_blockchain(alt_chain, false);
       if (r)
@@ -1408,7 +1413,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
     }
     else
     {
-      LOG_PRINT_BLUE("----- BLOCK ADDED AS ALTERNATIVE ON HEIGHT " << bei.height << std::endl << "id:\t" << id << std::endl << "PoW:\t" << proof_of_work << std::endl << "difficulty:\t" << current_diff, LOG_LEVEL_0);
+      MGINFO_BLUE("----- BLOCK ADDED AS ALTERNATIVE ON HEIGHT " << bei.height << std::endl << "id:\t" << id << std::endl << "PoW:\t" << proof_of_work << std::endl << "difficulty:\t" << current_diff);
       return true;
     }
   }
@@ -1416,7 +1421,7 @@ bool Blockchain::handle_alternative_block(const block& b, const crypto::hash& id
   {
     //block orphaned
     bvc.m_marked_as_orphaned = true;
-    LOG_PRINT_RED_L1("Block recognized as orphaned and rejected, id = " << id);
+    MERROR_VER("Block recognized as orphaned and rejected, id = " << id);
   }
 
   return true;
@@ -1805,7 +1810,7 @@ bool Blockchain::find_blockchain_supplement(const std::list<crypto::hash>& qbloc
   // how can we expect to sync from the client that the block list came from?
   if(!qblock_ids.size() /*|| !req.m_total_height*/)
   {
-    LOG_PRINT_L1("Client sent wrong NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << qblock_ids.size() << /*", m_height=" << req.m_total_height <<*/ ", dropping connection");
+    MCERROR("net.p2p", "Client sent wrong NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << qblock_ids.size() << /*", m_height=" << req.m_total_height <<*/ ", dropping connection");
     return false;
   }
 
@@ -1815,7 +1820,7 @@ bool Blockchain::find_blockchain_supplement(const std::list<crypto::hash>& qbloc
   auto gen_hash = m_db->get_block_hash_from_height(0);
   if(qblock_ids.back() != gen_hash)
   {
-    LOG_PRINT_L1("Client sent wrong NOTIFY_REQUEST_CHAIN: genesis block mismatch: " << std::endl << "id: " << qblock_ids.back() << ", " << std::endl << "expected: " << gen_hash << "," << std::endl << " dropping connection");
+    MCERROR("net.p2p", "Client sent wrong NOTIFY_REQUEST_CHAIN: genesis block mismatch: " << std::endl << "id: " << qblock_ids.back() << ", " << std::endl << "expected: " << gen_hash << "," << std::endl << " dropping connection");
 	m_db->block_txn_abort();
     return false;
   }
@@ -1833,7 +1838,7 @@ bool Blockchain::find_blockchain_supplement(const std::list<crypto::hash>& qbloc
     }
     catch (const std::exception& e)
     {
-      LOG_PRINT_L1("Non-critical error trying to find block by hash in BlockchainDB, hash: " << *bl_it);
+      MWARNING("Non-critical error trying to find block by hash in BlockchainDB, hash: " << *bl_it);
 	  m_db->block_txn_abort();
       return false;
     }
@@ -1844,7 +1849,7 @@ bool Blockchain::find_blockchain_supplement(const std::list<crypto::hash>& qbloc
   // but just in case...
   if(bl_it == qblock_ids.end())
   {
-    LOG_PRINT_L1("Internal error handling connection, can't find split point");
+    MERROR("Internal error handling connection, can't find split point");
     return false;
   }
 
@@ -1863,7 +1868,7 @@ uint64_t Blockchain::block_difficulty(uint64_t i) const
   }
   catch (const BLOCK_DNE& e)
   {
-    LOG_PRINT_L0("Attempted to get block difficulty for height above blockchain height");
+    MERROR("Attempted to get block difficulty for height above blockchain height");
   }
   return 0;
 }
@@ -1928,7 +1933,7 @@ void Blockchain::print_blockchain(uint64_t start_index, uint64_t end_index) cons
   auto h = m_db->height();
   if(start_index > h)
   {
-    LOG_PRINT_L1("Wrong starter index set: " << start_index << ", expected max index " << h);
+    MERROR("Wrong starter index set: " << start_index << ", expected max index " << h);
     return;
   }
 
@@ -1936,8 +1941,7 @@ void Blockchain::print_blockchain(uint64_t start_index, uint64_t end_index) cons
   {
     ss << "height " << i << ", timestamp " << m_db->get_block_timestamp(i) << ", cumul_dif " << m_db->get_block_cumulative_difficulty(i) << ", size " << m_db->get_block_size(i) << "\nid\t\t" << m_db->get_block_hash_from_height(i) << "\ndifficulty\t\t" << m_db->get_block_difficulty(i) << ", nonce " << m_db->get_block_from_height(i).nonce << ", tx_count " << m_db->get_block_from_height(i).tx_hashes.size() << std::endl;
   }
-  LOG_PRINT_L1("Current blockchain:" << std::endl << ss.str());
+  MCINFO("globlal", "Current blockchain:" << std::endl << ss.str());
-  LOG_PRINT_L0("Blockchain printed with log level 1");
 }
 //------------------------------------------------------------------
 void Blockchain::print_blockchain_index() const
@@ -1954,7 +1958,7 @@ void Blockchain::print_blockchain_index() const
     }
   }
 
-  LOG_PRINT_L0("Current blockchain index:" << std::endl << ss.str());
+  MINFO("Current blockchain index:" << std::endl << ss.str());
 }
 //------------------------------------------------------------------
 //TODO: remove this function and references to it
@@ -2041,7 +2045,7 @@ bool Blockchain::add_block_as_invalid(const block_extended_info& bei, const cryp
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
   auto i_res = m_invalid_blocks.insert(std::map<crypto::hash, block_extended_info>::value_type(h, bei));
   CHECK_AND_ASSERT_MES(i_res.second, false, "at insertion invalid by tx returned status existed");
-  LOG_PRINT_L1("BLOCK ADDED AS INVALID: " << h << std::endl << ", prev_id=" << bei.bl.prev_id << ", m_invalid_blocks count=" << m_invalid_blocks.size());
+  MINFO("BLOCK ADDED AS INVALID: " << h << std::endl << ", prev_id=" << bei.bl.prev_id << ", m_invalid_blocks count=" << m_invalid_blocks.size());
   return true;
 }
 //------------------------------------------------------------------
@@ -2158,7 +2162,7 @@ bool Blockchain::get_tx_outputs_gindexs(const crypto::hash& tx_id, std::vector<u
   uint64_t tx_index;
   if (!m_db->tx_exists(tx_id, tx_index))
   {
-    LOG_PRINT_RED_L1("warning: get_tx_outputs_gindexs failed to find transaction with id = " << tx_id);
+    MERROR_VER("get_tx_outputs_gindexs failed to find transaction with id = " << tx_id);
     return false;
   }
 
@@ -2200,7 +2204,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, uint64_t& max_used_block_heigh
     if(m_show_time_stats)
     {
       size_t mixin = tx.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(tx.vin[0]).key_offsets.size() - 1 : 0;
-      LOG_PRINT_L0("HASH: " << "-" << " I/M/O: " << tx.vin.size() << "/" << mixin << "/" << tx.vout.size() << " H: " << 0 << " chcktx: " << a);
+      MINFO("HASH: " << "-" << " I/M/O: " << tx.vin.size() << "/" << mixin << "/" << tx.vout.size() << " H: " << 0 << " chcktx: " << a);
     }
     return true;
   }
@@ -2212,7 +2216,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, uint64_t& max_used_block_heigh
   if(m_show_time_stats)
   {
     size_t mixin = tx.vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(tx.vin[0]).key_offsets.size() - 1 : 0;
-    LOG_PRINT_L0("HASH: " <<  get_transaction_hash(tx) << " I/M/O: " << tx.vin.size() << "/" << mixin << "/" << tx.vout.size() << " H: " << max_used_block_height << " ms: " << a + m_fake_scan_time << " B: " << get_object_blobsize(tx));
+    MINFO("HASH: " <<  get_transaction_hash(tx) << " I/M/O: " << tx.vin.size() << "/" << mixin << "/" << tx.vout.size() << " H: " << max_used_block_height << " ms: " << a + m_fake_scan_time << " B: " << get_object_blobsize(tx));
   }
   if (!res)
     return false;
@@ -2388,7 +2392,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
         else
         {
           uint64_t n_outputs = m_db->get_num_outputs(in_to_key.amount);
-          LOG_PRINT_L2("output size " << print_money(in_to_key.amount) << ": " << n_outputs << " available");
+          MDEBUG("output size " << print_money(in_to_key.amount) << ": " << n_outputs << " available");
           // n_outputs includes the output we're considering
           if (n_outputs <= min_mixin)
             ++n_unmixable;
@@ -2404,13 +2408,13 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
     {
       if (n_unmixable == 0)
       {
-        LOG_PRINT_L1("Tx " << get_transaction_hash(tx) << " has too low mixin (" << mixin << "), and no unmixable inputs");
+        MERROR_VER("Tx " << get_transaction_hash(tx) << " has too low mixin (" << mixin << "), and no unmixable inputs");
         tvc.m_low_mixin = true;
         return false;
       }
       if (n_mixable > 1)
       {
-        LOG_PRINT_L1("Tx " << get_transaction_hash(tx) << " has too low mixin (" << mixin << "), and more than one mixable input with unmixable inputs");
+        MERROR_VER("Tx " << get_transaction_hash(tx) << " has too low mixin (" << mixin << "), and more than one mixable input with unmixable inputs");
         tvc.m_low_mixin = true;
         return false;
       }
@@ -2420,14 +2424,14 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
     const size_t max_tx_version = (hf_version <= 3) ? 1 : 2;
     if (tx.version > max_tx_version)
     {
-      LOG_PRINT_L1("transaction version " << (unsigned)tx.version << " is higher than max accepted version " << max_tx_version);
+      MERROR_VER("transaction version " << (unsigned)tx.version << " is higher than max accepted version " << max_tx_version);
       tvc.m_verifivation_failed = true;
       return false;
     }
     const size_t min_tx_version = (n_unmixable > 0 ? 1 : (hf_version >= 5) ? 2 : 1);
     if (tx.version < min_tx_version)
     {
-      LOG_PRINT_L1("transaction version " << (unsigned)tx.version << " is lower than min accepted version " << min_tx_version);
+      MERROR_VER("transaction version " << (unsigned)tx.version << " is lower than min accepted version " << min_tx_version);
       tvc.m_verifivation_failed = true;
       return false;
     }
@@ -2486,7 +2490,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
 
     if(have_tx_keyimg_as_spent(in_to_key.k_image))
     {
-      LOG_PRINT_L1("Key image already spent in blockchain: " << epee::string_tools::pod_to_hex(in_to_key.k_image));
+      MERROR_VER("Key image already spent in blockchain: " << epee::string_tools::pod_to_hex(in_to_key.k_image));
       tvc.m_double_spend = true;
       return false;
     }
@@ -2502,7 +2506,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
       {
         if(!itk->second)
         {
-          LOG_PRINT_L1("Failed ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
+          MERROR_VER("Failed ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
           return false;
         }
 
@@ -2518,10 +2522,10 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
     if (!check_tx_input(tx.version, in_to_key, tx_prefix_hash, tx.version == 1 ? tx.signatures[sig_index] : std::vector<crypto::signature>(), tx.rct_signatures, pubkeys[sig_index], pmax_used_block_height))
     {
       it->second[in_to_key.k_image] = false;
-      LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
+      MERROR_VER("Failed to check ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
       if (pmax_used_block_height) // a default value of NULL is used when called from Blockchain::handle_block_to_main_chain()
       {
-        LOG_PRINT_L1("  *pmax_used_block_height: " << *pmax_used_block_height);
+        MERROR_VER("  *pmax_used_block_height: " << *pmax_used_block_height);
       }
 
       return false;
@@ -2541,11 +2545,11 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
         if (!results[sig_index])
         {
           it->second[in_to_key.k_image] = false;
-          LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
+          MERROR_VER("Failed to check ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
 
           if (pmax_used_block_height)  // a default value of NULL is used when called from Blockchain::handle_block_to_main_chain()
           {
-            LOG_PRINT_L1("*pmax_used_block_height: " << *pmax_used_block_height);
+            MERROR_VER("*pmax_used_block_height: " << *pmax_used_block_height);
           }
 
           return false;
@@ -2575,7 +2579,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
 
       if (failed)
       {
-        LOG_PRINT_L1("Failed to check ring signatures!, t_loop: " << t_t1);
+        MERROR_VER("Failed to check ring signatures!, t_loop: " << t_t1);
         return false;
       }
     }
@@ -2584,7 +2588,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
   {
     if (!expand_transaction_2(tx, tx_prefix_hash, pubkeys))
     {
-      LOG_PRINT_L1("Failed to expand rct signatures!");
+      MERROR_VER("Failed to expand rct signatures!");
       return false;
     }
 
@@ -2596,7 +2600,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
     {
     case rct::RCTTypeNull: {
       // we only accept no signatures for coinbase txes
-      LOG_PRINT_L1("Null rct signature on non-coinbase tx");
+      MERROR_VER("Null rct signature on non-coinbase tx");
       return false;
     }
     case rct::RCTTypeSimple: {
@@ -2604,14 +2608,14 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
       {
         if (pubkeys.size() != rv.mixRing.size())
         {
-          LOG_PRINT_L1("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
+          MERROR_VER("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
           return false;
         }
         for (size_t i = 0; i < pubkeys.size(); ++i)
         {
           if (pubkeys[i].size() != rv.mixRing[i].size())
           {
-            LOG_PRINT_L1("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
+            MERROR_VER("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
             return false;
           }
         }
@@ -2622,12 +2626,12 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
           {
             if (pubkeys[n][m].dest != rct::rct2pk(rv.mixRing[n][m].dest))
             {
-              LOG_PRINT_L1("Failed to check ringct signatures: mismatched pubkey at vin " << n << ", index " << m);
+              MERROR_VER("Failed to check ringct signatures: mismatched pubkey at vin " << n << ", index " << m);
               return false;
             }
             if (pubkeys[n][m].mask != rct::rct2pk(rv.mixRing[n][m].mask))
             {
-              LOG_PRINT_L1("Failed to check ringct signatures: mismatched commitment at vin " << n << ", index " << m);
+              MERROR_VER("Failed to check ringct signatures: mismatched commitment at vin " << n << ", index " << m);
               return false;
             }
           }
@@ -2636,21 +2640,21 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
 
       if (rv.p.MGs.size() != tx.vin.size())
       {
-        LOG_PRINT_L1("Failed to check ringct signatures: mismatched MGs/vin sizes");
+        MERROR_VER("Failed to check ringct signatures: mismatched MGs/vin sizes");
         return false;
       }
       for (size_t n = 0; n < tx.vin.size(); ++n)
       {
         if (memcmp(&boost::get<txin_to_key>(tx.vin[n]).k_image, &rv.p.MGs[n].II[0], 32))
         {
-          LOG_PRINT_L1("Failed to check ringct signatures: mismatched key image");
+          MERROR_VER("Failed to check ringct signatures: mismatched key image");
           return false;
         }
       }
 
       if (!rct::verRctSimple(rv, false))
       {
-        LOG_PRINT_L1("Failed to check ringct signatures!");
+        MERROR_VER("Failed to check ringct signatures!");
         return false;
       }
       break;
@@ -2665,7 +2669,7 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
           size_matches &= pubkeys.size() == rv.mixRing[i].size();
         if (!size_matches)
         {
-          LOG_PRINT_L1("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
+          MERROR_VER("Failed to check ringct signatures: mismatched pubkeys/mixRing size");
           return false;
         }
 
@@ -2675,12 +2679,12 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
           {
             if (pubkeys[n][m].dest != rct::rct2pk(rv.mixRing[m][n].dest))
             {
-              LOG_PRINT_L1("Failed to check ringct signatures: mismatched pubkey at vin " << n << ", index " << m);
+              MERROR_VER("Failed to check ringct signatures: mismatched pubkey at vin " << n << ", index " << m);
               return false;
             }
             if (pubkeys[n][m].mask != rct::rct2pk(rv.mixRing[m][n].mask))
             {
-              LOG_PRINT_L1("Failed to check ringct signatures: mismatched commitment at vin " << n << ", index " << m);
+              MERROR_VER("Failed to check ringct signatures: mismatched commitment at vin " << n << ", index " << m);
               return false;
             }
           }
@@ -2689,32 +2693,32 @@ bool Blockchain::check_tx_inputs(transaction& tx, tx_verification_context &tvc,
 
       if (rv.p.MGs.size() != 1)
       {
-        LOG_PRINT_L1("Failed to check ringct signatures: Bad MGs size");
+        MERROR_VER("Failed to check ringct signatures: Bad MGs size");
         return false;
       }
       if (rv.p.MGs[0].II.size() != tx.vin.size())
       {
-        LOG_PRINT_L1("Failed to check ringct signatures: mismatched II/vin sizes");
+        MERROR_VER("Failed to check ringct signatures: mismatched II/vin sizes");
         return false;
       }
       for (size_t n = 0; n < tx.vin.size(); ++n)
       {
         if (memcmp(&boost::get<txin_to_key>(tx.vin[n]).k_image, &rv.p.MGs[0].II[n], 32))
         {
-          LOG_PRINT_L1("Failed to check ringct signatures: mismatched II/vin sizes");
+          MERROR_VER("Failed to check ringct signatures: mismatched II/vin sizes");
           return false;
         }
       }
 
       if (!rct::verRct(rv, false))
       {
-        LOG_PRINT_L1("Failed to check ringct signatures!");
+        MERROR_VER("Failed to check ringct signatures!");
         return false;
       }
       break;
     }
     default:
-      LOG_PRINT_L1("Unsupported rct type: " << rv.type);
+      MERROR_VER("Unsupported rct type: " << rv.type);
       return false;
     }
   }
@@ -2777,7 +2781,7 @@ bool Blockchain::check_fee(size_t blob_size, uint64_t fee) const
       return false;
     fee_per_kb = get_dynamic_per_kb_fee(base_reward, median);
   }
-  LOG_PRINT_L2("Using " << print_money(fee) << "/kB fee");
+  MDEBUG("Using " << print_money(fee) << "/kB fee");
 
   uint64_t needed_fee = blob_size / 1024;
   needed_fee += (blob_size % 1024) ? 1 : 0;
@@ -2785,7 +2789,7 @@ bool Blockchain::check_fee(size_t blob_size, uint64_t fee) const
 
   if (fee < needed_fee)
   {
-    LOG_PRINT_L1("transaction fee is not enough: " << print_money(fee) << ", minimum fee: " << print_money(needed_fee));
+    MERROR_VER("transaction fee is not enough: " << print_money(fee) << ", minimum fee: " << print_money(needed_fee));
     return false;
   }
   return true;
@@ -2815,12 +2819,12 @@ uint64_t Blockchain::get_dynamic_per_kb_fee_estimate(uint64_t grace_blocks) cons
   uint64_t base_reward;
   if (!get_block_reward(median, 1, already_generated_coins, base_reward, version))
   {
-    LOG_PRINT_L1("Failed to determine block reward, using placeholder " << print_money(BLOCK_REWARD_OVERESTIMATE) << " as a high bound");
+    MERROR("Failed to determine block reward, using placeholder " << print_money(BLOCK_REWARD_OVERESTIMATE) << " as a high bound");
     base_reward = BLOCK_REWARD_OVERESTIMATE;
   }
 
   uint64_t fee = get_dynamic_per_kb_fee(base_reward, median);
-  LOG_PRINT_L2("Estimating " << grace_blocks << "-block fee at " << print_money(fee) << "/kB");
+  MDEBUG("Estimating " << grace_blocks << "-block fee at " << print_money(fee) << "/kB");
   return fee;
 }
 
@@ -2875,7 +2879,7 @@ bool Blockchain::check_tx_input(size_t tx_version, const txin_to_key& txin, cons
       //check tx unlock time
       if (!m_bch.is_tx_spendtime_unlocked(unlock_time))
       {
-        LOG_PRINT_L1("One of outputs for one of inputs has wrong tx.unlock_time = " << unlock_time);
+        MERROR_VER("One of outputs for one of inputs has wrong tx.unlock_time = " << unlock_time);
         return false;
       }
 
@@ -2895,13 +2899,13 @@ bool Blockchain::check_tx_input(size_t tx_version, const txin_to_key& txin, cons
   outputs_visitor vi(output_keys, *this);
   if (!scan_outputkeys_for_indexes(tx_version, txin, vi, tx_prefix_hash, pmax_related_block_height))
   {
-    LOG_PRINT_L1("Failed to get output keys for tx with amount = " << print_money(txin.amount) << " and count indexes " << txin.key_offsets.size());
+    MERROR_VER("Failed to get output keys for tx with amount = " << print_money(txin.amount) << " and count indexes " << txin.key_offsets.size());
     return false;
   }
 
   if(txin.key_offsets.size() != output_keys.size())
   {
-    LOG_PRINT_L1("Output keys for tx with amount = " << txin.amount << " and count indexes " << txin.key_offsets.size() << " returned wrong keys count " << output_keys.size());
+    MERROR_VER("Output keys for tx with amount = " << txin.amount << " and count indexes " << txin.key_offsets.size() << " returned wrong keys count " << output_keys.size());
     return false;
   }
   if (tx_version == 1) {
@@ -2927,7 +2931,7 @@ bool Blockchain::check_block_timestamp(std::vector<uint64_t>& timestamps, const
 
   if(b.timestamp < median_ts)
   {
-    LOG_PRINT_L1("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW << " blocks, " << median_ts);
+    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW << " blocks, " << median_ts);
     return false;
   }
 
@@ -2946,7 +2950,7 @@ bool Blockchain::check_block_timestamp(const block& b) const
   LOG_PRINT_L3("Blockchain::" << __func__);
   if(b.timestamp > get_adjusted_time() + CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT)
   {
-    LOG_PRINT_L1("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than adjusted time + 2 hours");
+    MERROR_VER("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than adjusted time + 2 hours");
     return false;
   }
 
@@ -2982,7 +2986,7 @@ void Blockchain::return_tx_to_pool(const std::vector<transaction> &txs)
     // all the transactions in a popped block when a reorg happens.
     if (!m_tx_pool.add_tx(tx, tvc, true, true, false, version))
     {
-      LOG_PRINT_L0("Failed to return taken transaction with hash: " << get_transaction_hash(tx) << " to tx_pool");
+      MERROR("Failed to return taken transaction with hash: " << get_transaction_hash(tx) << " to tx_pool");
     }
   }
 }
@@ -2998,10 +3002,10 @@ bool Blockchain::flush_txes_from_pool(const std::list<crypto::hash> &txids)
     size_t blob_size;
     uint64_t fee;
     bool relayed, do_not_relay;
-    LOG_PRINT_L1("Removing txid " << txid << " from the pool");
+    MINFO("Removing txid " << txid << " from the pool");
     if(m_tx_pool.have_tx(txid) && !m_tx_pool.take_tx(txid, tx, blob_size, fee, relayed, do_not_relay))
     {
-      LOG_PRINT_L0("Failed to remove txid " << txid << " from the pool");
+      MERROR("Failed to remove txid " << txid << " from the pool");
       res = false;
     }
   }
@@ -3022,7 +3026,7 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
   m_db->block_txn_start(true);
   if(bl.prev_id != get_tail_id())
   {
-    LOG_PRINT_L1("Block with id: " << id << std::endl << "has wrong prev_id: " << bl.prev_id << std::endl << "expected: " << get_tail_id());
+    MERROR_VER("Block with id: " << id << std::endl << "has wrong prev_id: " << bl.prev_id << std::endl << "expected: " << get_tail_id());
 leave:
     m_db->block_txn_stop();
     return false;
@@ -3031,7 +3035,7 @@ leave:
   // this is a cheap test
   if (!m_hardfork->check(bl))
   {
-    LOG_PRINT_L1("Block with id: " << id << std::endl << "has old version: " << (unsigned)bl.major_version << std::endl << "current: " << (unsigned)m_hardfork->get_current_version());
+    MERROR_VER("Block with id: " << id << std::endl << "has old version: " << (unsigned)bl.major_version << std::endl << "current: " << (unsigned)m_hardfork->get_current_version());
     bvc.m_verifivation_failed = true;
     goto leave;
   }
@@ -3043,7 +3047,7 @@ leave:
   // of a set number of the most recent blocks.
   if(!check_block_timestamp(bl))
   {
-    LOG_PRINT_L1("Block with id: " << id << std::endl << "has invalid timestamp: " << bl.timestamp);
+    MERROR_VER("Block with id: " << id << std::endl << "has invalid timestamp: " << bl.timestamp);
     bvc.m_verifivation_failed = true;
     goto leave;
   }
@@ -3083,7 +3087,7 @@ leave:
     auto hash = get_block_hash(bl);
     if (memcmp(&hash, &m_blocks_hash_check[m_db->height()], sizeof(hash)) != 0)
     {
-      LOG_PRINT_L1("Block with id is INVALID: " << id);
+      MERROR_VER("Block with id is INVALID: " << id);
       bvc.m_verifivation_failed = true;
       goto leave;
     }
@@ -3104,7 +3108,7 @@ leave:
     // validate proof_of_work versus difficulty target
     if(!check_hash(proof_of_work, current_diffic))
     {
-      LOG_PRINT_L1("Block with id: " << id << std::endl << "does not have enough proof of work: " << proof_of_work << std::endl << "unexpected difficulty: " << current_diffic);
+      MERROR_VER("Block with id: " << id << std::endl << "does not have enough proof of work: " << proof_of_work << std::endl << "unexpected difficulty: " << current_diffic);
       bvc.m_verifivation_failed = true;
       goto leave;
     }
@@ -3131,7 +3135,7 @@ leave:
   // sanity check basic miner tx properties;
   if(!prevalidate_miner_transaction(bl, m_db->height()))
   {
-    LOG_PRINT_L1("Block with id: " << id << " failed to pass prevalidation");
+    MERROR_VER("Block with id: " << id << " failed to pass prevalidation");
     bvc.m_verifivation_failed = true;
     goto leave;
   }
@@ -3166,7 +3170,7 @@ leave:
 // XXX old code does not check whether tx exists
     if (m_db->tx_exists(tx_id))
     {
-      LOG_PRINT_L1("Block with id: " << id << " attempting to add transaction already in blockchain with id: " << tx_id);
+      MERROR("Block with id: " << id << " attempting to add transaction already in blockchain with id: " << tx_id);
       bvc.m_verifivation_failed = true;
       return_tx_to_pool(txs);
       goto leave;
@@ -3179,7 +3183,7 @@ leave:
     // get transaction with hash <tx_id> from tx_pool
     if(!m_tx_pool.take_tx(tx_id, tx, blob_size, fee, relayed, do_not_relay))
     {
-      LOG_PRINT_L1("Block with id: " << id  << " has at least one unknown transaction with id: " << tx_id);
+      MERROR_VER("Block with id: " << id  << " has at least one unknown transaction with id: " << tx_id);
       bvc.m_verifivation_failed = true;
       return_tx_to_pool(txs);
       goto leave;
@@ -3218,11 +3222,11 @@ leave:
       tx_verification_context tvc;
       if(!check_tx_inputs(tx, tvc))
       {
-        LOG_PRINT_L1("Block with id: " << id  << " has at least one transaction (id: " << tx_id << ") with wrong inputs.");
+        MERROR_VER("Block with id: " << id  << " has at least one transaction (id: " << tx_id << ") with wrong inputs.");
 
         //TODO: why is this done?  make sure that keeping invalid blocks makes sense.
         add_block_as_invalid(bl, id);
-        LOG_PRINT_L1("Block with id " << id << " added as invalid because of wrong inputs in transactions");
+        MERROR_VER("Block with id " << id << " added as invalid because of wrong inputs in transactions");
         bvc.m_verifivation_failed = true;
         return_tx_to_pool(txs);
         goto leave;
@@ -3235,10 +3239,10 @@ leave:
       // the transaction inputs, but do some sanity checks anyway.
       if (memcmp(&m_blocks_txs_check[tx_index++], &tx_id, sizeof(tx_id)) != 0)
       {
-        LOG_PRINT_L1("Block with id: " << id << " has at least one transaction (id: " << tx_id << ") with wrong inputs.");
+        MERROR_VER("Block with id: " << id << " has at least one transaction (id: " << tx_id << ") with wrong inputs.");
         //TODO: why is this done?  make sure that keeping invalid blocks makes sense.
         add_block_as_invalid(bl, id);
-        LOG_PRINT_L1("Block with id " << id << " added as invalid because of wrong inputs in transactions");
+        MERROR_VER("Block with id " << id << " added as invalid because of wrong inputs in transactions");
         bvc.m_verifivation_failed = true;
         return_tx_to_pool(txs);
         goto leave;
@@ -3258,7 +3262,7 @@ leave:
   uint64_t already_generated_coins = m_db->height() ? m_db->get_block_already_generated_coins(m_db->height() - 1) : 0;
   if(!validate_miner_transaction(bl, cumulative_block_size, fee_summary, base_reward, already_generated_coins, bvc.m_partial_block_reward, m_hardfork->get_current_version()))
   {
-    LOG_PRINT_L1("Block with id: " << id << " has incorrect miner transaction");
+    MERROR_VER("Block with id: " << id << " has incorrect miner transaction");
     bvc.m_verifivation_failed = true;
     return_tx_to_pool(txs);
     goto leave;
@@ -3317,10 +3321,10 @@ leave:
   // do this after updating the hard fork state since the size limit may change due to fork
   update_next_cumulative_size_limit();
 
-  LOG_PRINT_L1("+++++ BLOCK SUCCESSFULLY ADDED" << std::endl << "id:\t" << id << std::endl << "PoW:\t" << proof_of_work << std::endl << "HEIGHT " << new_height-1 << ", difficulty:\t" << current_diffic << std::endl << "block reward: " << print_money(fee_summary + base_reward) << "(" << print_money(base_reward) << " + " << print_money(fee_summary) << "), coinbase_blob_size: " << coinbase_blob_size << ", cumulative size: " << cumulative_block_size << ", " << block_processing_time << "(" << target_calculating_time << "/" << longhash_calculating_time << ")ms");
+  MINFO("+++++ BLOCK SUCCESSFULLY ADDED" << std::endl << "id:\t" << id << std::endl << "PoW:\t" << proof_of_work << std::endl << "HEIGHT " << new_height-1 << ", difficulty:\t" << current_diffic << std::endl << "block reward: " << print_money(fee_summary + base_reward) << "(" << print_money(base_reward) << " + " << print_money(fee_summary) << "), coinbase_blob_size: " << coinbase_blob_size << ", cumulative size: " << cumulative_block_size << ", " << block_processing_time << "(" << target_calculating_time << "/" << longhash_calculating_time << ")ms");
   if(m_show_time_stats)
   {
-    LOG_PRINT_L0("Height: " << new_height << " blob: " << coinbase_blob_size << " cumm: "
+    MINFO("Height: " << new_height << " blob: " << coinbase_blob_size << " cumm: "
         << cumulative_block_size << " p/t: " << block_processing_time << " ("
         << target_calculating_time << "/" << longhash_calculating_time << "/"
         << t1 << "/" << t2 << "/" << t3 << "/" << t_exists << "/" << t_pool
@@ -3448,7 +3452,7 @@ bool Blockchain::update_checkpoints(const std::string& file_path, bool check_dns
     }
     else
     {
-      LOG_PRINT_L0("One or more checkpoints fetched from DNS conflicted with existing checkpoints!");
+      MERROR("One or more checkpoints fetched from DNS conflicted with existing checkpoints!");
     }
   }
 
@@ -3486,7 +3490,7 @@ void Blockchain::block_longhash_worker(const uint64_t height, const std::vector<
 //------------------------------------------------------------------
 bool Blockchain::cleanup_handle_incoming_blocks(bool force_sync)
 {
-  LOG_PRINT_YELLOW("Blockchain::" << __func__, LOG_LEVEL_3);
+  MTRACE("Blockchain::" << __func__);
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
   TIME_MEASURE_START(t1);
 
@@ -3536,7 +3540,7 @@ void Blockchain::output_scan_worker(const uint64_t amount, const std::vector<uin
   }
   catch (const std::exception& e)
   {
-    LOG_PRINT_L1("EXCEPTION: " << e.what());
+    MERROR_VER("EXCEPTION: " << e.what());
   }
   catch (...)
   {
@@ -3553,7 +3557,7 @@ void Blockchain::output_scan_worker(const uint64_t amount, const std::vector<uin
 //    keys.
 bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_entry> &blocks_entry)
 {
-  LOG_PRINT_YELLOW("Blockchain::" << __func__, LOG_LEVEL_3);
+  MTRACE("Blockchain::" << __func__);
   TIME_MEASURE_START(prepare);
   bool stop_batch;
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
@@ -3583,7 +3587,7 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
     std::vector<boost::thread *> thread_list;
     int batches = blocks_entry.size() / threads;
     int extra = blocks_entry.size() % threads;
-    LOG_PRINT_L1("block_batches: " << batches);
+    MDEBUG("block_batches: " << batches);
     std::vector<std::unordered_map<crypto::hash, crypto::hash>> maps(threads);
     std::vector < std::vector < block >> blocks(threads);
     auto it = blocks_entry.begin();
@@ -3606,7 +3610,7 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
           crypto::hash tophash = m_db->top_block_hash();
           if (block.prev_id != tophash)
           {
-            LOG_PRINT_L1("Skipping prepare blocks. New blocks don't belong to chain.");
+            MDEBUG("Skipping prepare blocks. New blocks don't belong to chain.");
             return true;
           }
         }
@@ -3672,7 +3676,7 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
 
   if (blocks_exist)
   {
-    LOG_PRINT_L0("Skipping prepare blocks. Blocks exist.");
+    MDEBUG("Skipping prepare blocks. Blocks exist.");
     return true;
   }
 
@@ -3686,7 +3690,7 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
   m_fake_pow_calc_time = prepare / blocks_entry.size();
 
   if (blocks_entry.size() > 1 && threads > 1 && m_show_time_stats)
-    LOG_PRINT_L0("Prepare blocks took: " << prepare << " ms");
+    MDEBUG("Prepare blocks took: " << prepare << " ms");
 
   TIME_MEASURE_START(scantable);
 
@@ -3699,7 +3703,7 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
 
 #define SCAN_TABLE_QUIT(m) \
         do { \
-            LOG_PRINT_L0(m) ;\
+            MERROR_VER(m) ;\
             m_scan_table.clear(); \
             return false; \
         } while(0); \
@@ -3873,7 +3877,7 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
   {
     m_fake_scan_time = scantable / total_txs;
     if(m_show_time_stats)
-      LOG_PRINT_L0("Prepare scantable took: " << scantable << " ms");
+      MDEBUG("Prepare scantable took: " << scantable << " ms");
   }
 
   return true;
@@ -3951,7 +3955,7 @@ void Blockchain::load_compiled_in_block_hashes()
       const size_t size_needed = 4 + nblocks * sizeof(crypto::hash);
       if(nblocks > 0 && nblocks > m_db->height() && get_blocks_dat_size(m_testnet) >= size_needed)
       {
-        LOG_PRINT_L0("Loading precomputed blocks: " << nblocks);
+        MINFO("Loading precomputed blocks: " << nblocks);
         p += sizeof(uint32_t);
         for (uint32_t i = 0; i < nblocks; i++)
         {

src/cryptonote_core/checkpoints.cpp

@@ -39,6 +39,9 @@ using namespace epee;
 #include <sstream>
 #include <random>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "checkpoints"
+
 namespace
 {
   bool dns_records_match(const std::vector<std::string>& a, const std::vector<std::string>& b)
@@ -99,11 +102,11 @@ namespace cryptonote
 
     if(it->second == h)
     {
-      LOG_PRINT_GREEN("CHECKPOINT PASSED FOR HEIGHT " << height << " " << h, LOG_LEVEL_1);
+      MINFO("CHECKPOINT PASSED FOR HEIGHT " << height << " " << h);
       return true;
     }else
     {
-      LOG_ERROR("CHECKPOINT FAILED FOR HEIGHT " << height << ". EXPECTED HASH: " << it->second << ", FETCHED HASH: " << h);
+      MWARNING("CHECKPOINT FAILED FOR HEIGHT " << height << ". EXPECTED HASH: " << it->second << ", FETCHED HASH: " << h);
       return false;
     }
   }

src/cryptonote_core/cryptonote_basic_impl.cpp

@@ -42,6 +42,9 @@ using namespace epee;
 #include "crypto/hash.h"
 #include "common/int-util.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "cn"
+
 namespace cryptonote {
 
   struct integrated_address {
@@ -98,7 +101,7 @@ namespace cryptonote {
     }
 
     if(current_block_size > 2 * median_size) {
-      LOG_PRINT_L4("Block cumulative size is too big: " << current_block_size << ", expected less than " << 2 * median_size);
+      MERROR("Block cumulative size is too big: " << current_block_size << ", expected less than " << 2 * median_size);
       return false;
     }
 

src/cryptonote_core/cryptonote_core.cpp

@@ -51,8 +51,13 @@ using namespace epee;
 #endif
 #include "ringct/rctSigs.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "cn"
+
 DISABLE_VS_WARNINGS(4355)
 
+#define MERROR_VER(x) MCERROR("verify", x)
+
 namespace cryptonote
 {
 
@@ -282,10 +287,10 @@ namespace cryptonote
       const boost::filesystem::path old_files = folder;
       if (boost::filesystem::exists(old_files / "blockchain.bin"))
       {
-        LOG_PRINT_RED_L0("Found old-style blockchain.bin in " << old_files.string());
+        MWARNING("Found old-style blockchain.bin in " << old_files.string());
-        LOG_PRINT_RED_L0("Monero now uses a new format. You can either remove blockchain.bin to start syncing");
+        MWARNING("Monero now uses a new format. You can either remove blockchain.bin to start syncing");
-        LOG_PRINT_RED_L0("the blockchain anew, or use monero-blockchain-export and monero-blockchain-import to");
+        MWARNING("the blockchain anew, or use monero-blockchain-export and monero-blockchain-import to");
-        LOG_PRINT_RED_L0("convert your existing blockchain.bin to the new format. See README.md for instructions.");
+        MWARNING("convert your existing blockchain.bin to the new format. See README.md for instructions.");
         return false;
       }
     }
@@ -310,7 +315,7 @@ namespace cryptonote
     }
 
     folder /= db->get_db_name();
-    LOG_PRINT_L0("Loading blockchain from folder " << folder.string() << " ...");
+    MGINFO("Loading blockchain from folder " << folder.string() << " ...");
 
     const std::string filename = folder.string();
     // default to fast:async:1
@@ -326,7 +331,7 @@ namespace cryptonote
       boost::split(options, db_sync_mode, boost::is_any_of(" :"));
 
       for(const auto &option : options)
-        LOG_PRINT_L0("option: " << option);
+        MDEBUG("option: " << option);
 
       // default to fast:async:1
       uint64_t DEFAULT_FLAGS = DBS_FAST_MODE;
@@ -523,12 +528,12 @@ namespace cryptonote
 
     bool r = add_new_tx(tx, tx_hash, tx_prefixt_hash, tx_blob.size(), tvc, keeped_by_block, relayed, do_not_relay);
     if(tvc.m_verifivation_failed)
-    {LOG_PRINT_RED_L1("Transaction verification failed: " << tx_hash);}
+    {MERROR_VER("Transaction verification failed: " << tx_hash);}
     else if(tvc.m_verifivation_impossible)
-    {LOG_PRINT_RED_L1("Transaction verification impossible: " << tx_hash);}
+    {MERROR_VER("Transaction verification impossible: " << tx_hash);}
 
     if(tvc.m_added_to_pool)
-      LOG_PRINT_L1("tx added: " << tx_hash);
+      MDEBUG("tx added: " << tx_hash);
     return r;
   }
   //-----------------------------------------------------------------------------------------------
@@ -547,33 +552,33 @@ namespace cryptonote
   {
     if(!tx.vin.size())
     {
-      LOG_PRINT_RED_L1("tx with empty inputs, rejected for tx id= " << get_transaction_hash(tx));
+      MERROR_VER("tx with empty inputs, rejected for tx id= " << get_transaction_hash(tx));
       return false;
     }
 
     if(!check_inputs_types_supported(tx))
     {
-      LOG_PRINT_RED_L1("unsupported input types for tx id= " << get_transaction_hash(tx));
+      MERROR_VER("unsupported input types for tx id= " << get_transaction_hash(tx));
       return false;
     }
 
     if(!check_outs_valid(tx))
     {
-      LOG_PRINT_RED_L1("tx with invalid outputs, rejected for tx id= " << get_transaction_hash(tx));
+      MERROR_VER("tx with invalid outputs, rejected for tx id= " << get_transaction_hash(tx));
       return false;
     }
     if (tx.version > 1)
     {
       if (tx.rct_signatures.outPk.size() != tx.vout.size())
       {
-        LOG_PRINT_RED_L1("tx with mismatched vout/outPk count, rejected for tx id= " << get_transaction_hash(tx));
+        MERROR_VER("tx with mismatched vout/outPk count, rejected for tx id= " << get_transaction_hash(tx));
         return false;
       }
     }
 
     if(!check_money_overflow(tx))
     {
-      LOG_PRINT_RED_L1("tx has money overflow, rejected for tx id= " << get_transaction_hash(tx));
+      MERROR_VER("tx has money overflow, rejected for tx id= " << get_transaction_hash(tx));
       return false;
     }
 
@@ -585,7 +590,7 @@ namespace cryptonote
 
       if(amount_in <= amount_out)
       {
-        LOG_PRINT_RED_L1("tx with wrong amounts: ins " << amount_in << ", outs " << amount_out << ", rejected for tx id= " << get_transaction_hash(tx));
+        MERROR_VER("tx with wrong amounts: ins " << amount_in << ", outs " << amount_out << ", rejected for tx id= " << get_transaction_hash(tx));
         return false;
       }
     }
@@ -593,14 +598,14 @@ namespace cryptonote
 
     if(!keeped_by_block && get_object_blobsize(tx) >= m_blockchain_storage.get_current_cumulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE)
     {
-      LOG_PRINT_RED_L1("tx is too large " << get_object_blobsize(tx) << ", expected not bigger than " << m_blockchain_storage.get_current_cumulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
+      MERROR_VER("tx is too large " << get_object_blobsize(tx) << ", expected not bigger than " << m_blockchain_storage.get_current_cumulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
       return false;
     }
 
     //check if tx use different key images
     if(!check_tx_inputs_keyimages_diff(tx))
     {
-      LOG_PRINT_RED_L1("tx uses a single key image more than once");
+      MERROR_VER("tx uses a single key image more than once");
       return false;
     }
 
@@ -610,24 +615,24 @@ namespace cryptonote
       switch (rv.type) {
         case rct::RCTTypeNull:
           // coinbase should not come here, so we reject for all other types
-          LOG_PRINT_RED_L1("Unexpected Null rctSig type");
+          MERROR_VER("Unexpected Null rctSig type");
           return false;
         case rct::RCTTypeSimple:
           if (!rct::verRctSimple(rv, true))
           {
-            LOG_PRINT_RED_L1("rct signature semantics check failed");
+            MERROR_VER("rct signature semantics check failed");
             return false;
           }
           break;
         case rct::RCTTypeFull:
           if (!rct::verRct(rv, true))
           {
-            LOG_PRINT_RED_L1("rct signature semantics check failed");
+            MERROR_VER("rct signature semantics check failed");
             return false;
           }
           break;
         default:
-          LOG_PRINT_RED_L1("Unknown rct type: " << rv.type);
+          MERROR_VER("Unknown rct type: " << rv.type);
           return false;
       }
     }
@@ -992,10 +997,10 @@ namespace cryptonote
   {
     if(!m_starter_message_showed)
     {
-      LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL
+      MGINFO_YELLOW(ENDL << "**********************************************************************" << ENDL
         << "The daemon will start synchronizing with the network. It may take up to several hours." << ENDL
         << ENDL
-        << "You can set the level of process detailization* through \"set_log <level>\" command*, where <level> is between 0 (no details) and 4 (very verbose)." << ENDL
+        << "You can set the level of process detailization* through \"set_log <level|categories>\" command*, where <level> is between 0 (no details) and 4 (very verbose), or custom category based levels (eg, *:WARNING)" << ENDL
         << ENDL
         << "Use \"help\" command to see the list of available commands." << ENDL
         << ENDL
@@ -1014,19 +1019,18 @@ namespace cryptonote
   bool core::check_fork_time()
   {
     HardFork::State state = m_blockchain_storage.get_hard_fork_state();
+    const el::Level level = el::Level::Warning;
     switch (state) {
       case HardFork::LikelyForked:
-        LOG_PRINT_RED_L0(ENDL
+        MCLOG_RED(level, "global", "**********************************************************************");
-          << "**********************************************************************" << ENDL
+        MCLOG_RED(level, "global", "Last scheduled hard fork is too far in the past.");
-          << "Last scheduled hard fork is too far in the past." << ENDL
+        MCLOG_RED(level, "global", "We are most likely forked from the network. Daemon update needed now.");
-          << "We are most likely forked from the network. Daemon update needed now." << ENDL
+        MCLOG_RED(level, "global", "**********************************************************************");
-          << "**********************************************************************" << ENDL);
         break;
       case HardFork::UpdateNeeded:
-        LOG_PRINT_RED_L0(ENDL
+        MCLOG_RED(level, "global", "**********************************************************************");
-          << "**********************************************************************" << ENDL
+        MCLOG_RED(level, "global", "Last scheduled hard fork time shows a daemon update is needed now.");
-          << "Last scheduled hard fork time shows a daemon update is needed now." << ENDL
+        MCLOG_RED(level, "global", "**********************************************************************");
-          << "**********************************************************************" << ENDL);
         break;
       default:
         break;

src/cryptonote_core/cryptonote_format_utils.cpp

@@ -39,6 +39,9 @@ using namespace epee;
 #include "crypto/hash.h"
 #include "ringct/rctSigs.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "cn"
+
 #define ENCRYPTED_PAYMENT_ID_TAIL 0x8d
 
 static const uint64_t valid_decomposed_outputs[] = {
@@ -623,7 +626,7 @@ namespace cryptonote
       zero_secret_key &= (sender_account_keys.m_spend_secret_key.data[i] == 0);
     if (zero_secret_key)
     {
-      LOG_PRINT_L1("Null secret key, skipping signatures");
+      MDEBUG("Null secret key, skipping signatures");
     }
 
     if (tx.version == 1)
@@ -659,7 +662,7 @@ namespace cryptonote
         i++;
       }
 
-      LOG_PRINT2("construct_tx.log", "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL << ss_ring_s.str() , LOG_LEVEL_3);
+      MCINFO("construct_tx", "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL << ss_ring_s.str());
     }
     else
     {
@@ -764,7 +767,7 @@ namespace cryptonote
 
       CHECK_AND_ASSERT_MES(tx.vout.size() == outSk.size(), false, "outSk size does not match vout");
 
-      LOG_PRINT2("construct_tx.log", "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL, LOG_LEVEL_3);
+      MCINFO("construct_tx", "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL);
     }
 
     return true;

src/cryptonote_core/difficulty.cpp

@@ -39,6 +39,9 @@
 #include "cryptonote_config.h"
 #include "difficulty.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "difficulty"
+
 namespace cryptonote {
 
   using std::size_t;

src/cryptonote_core/hardfork.cpp

@@ -33,6 +33,9 @@
 #include "blockchain_db/blockchain_db.h"
 #include "hardfork.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "hardfork"
+
 using namespace cryptonote;
 
 static uint8_t get_block_vote(const cryptonote::block &b)

src/cryptonote_core/miner.cpp

@@ -43,6 +43,9 @@
 #include "string_coding.h"
 #include "storages/portable_storage_template_helper.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "miner"
+
 using namespace epee;
 
 #include "miner.h"
@@ -193,7 +196,7 @@ namespace cryptonote
       m_config_folder_path = boost::filesystem::path(command_line::get_arg(vm, arg_extra_messages)).parent_path().string();
       m_config = AUTO_VAL_INIT(m_config);
       epee::serialization::load_t_from_json_file(m_config, m_config_folder_path + "/" + MINER_CONFIG_FILE_NAME);
-      LOG_PRINT_L0("Loaded " << m_extra_messages.size() << " extra messages, current index " << m_config.current_extra_message_index);
+      MINFO("Loaded " << m_extra_messages.size() << " extra messages, current index " << m_config.current_extra_message_index);
     }
 
     if(command_line::has_arg(vm, arg_start_mining))
@@ -278,11 +281,11 @@ namespace cryptonote
   //-----------------------------------------------------------------------------------------------------
   bool miner::stop()
   {
-    LOG_PRINT_L1("Miner has received stop signal");
+    MTRACE("Miner has received stop signal");
 
     if (!is_mining())
     {
-      LOG_PRINT_L1("Not mining - nothing to stop" );
+      MDEBUG("Not mining - nothing to stop" );
       return true;
     }
 
@@ -292,7 +295,7 @@ namespace cryptonote
     BOOST_FOREACH(boost::thread& th, m_threads)
       th.join();
 
-    LOG_PRINT_L0("Mining has been stopped, " << m_threads.size() << " finished" );
+    MINFO("Mining has been stopped, " << m_threads.size() << " finished" );
     m_threads.clear();
     return true;
   }
@@ -328,7 +331,7 @@ namespace cryptonote
     CRITICAL_REGION_LOCAL(m_miners_count_lock);
     ++m_pausers_count;
     if(m_pausers_count == 1 && is_mining())
-      LOG_PRINT_L2("MINING PAUSED");
+      MDEBUG("MINING PAUSED");
   }
   //-----------------------------------------------------------------------------------------------------
   void miner::resume()
@@ -338,17 +341,17 @@ namespace cryptonote
     if(m_pausers_count < 0)
     {
       m_pausers_count = 0;
-      LOG_PRINT_RED_L0("Unexpected miner::resume() called");
+      MERROR("Unexpected miner::resume() called");
     }
     if(!m_pausers_count && is_mining())
-      LOG_PRINT_L2("MINING RESUMED");
+      MDEBUG("MINING RESUMED");
   }
   //-----------------------------------------------------------------------------------------------------
   bool miner::worker_thread()
   {
     uint32_t th_local_index = boost::interprocess::ipcdetail::atomic_inc32(&m_thread_index);
-    LOG_PRINT_L0("Miner thread was started ["<< th_local_index << "]");
+    MGINFO("Miner thread was started ["<< th_local_index << "]");
-    log_space::log_singletone::set_thread_log_prefix(std::string("[miner ") + std::to_string(th_local_index) + "]");
+    MLOG_SET_THREAD_NAME(std::string("[miner ") + std::to_string(th_local_index) + "]");
     uint32_t nonce = m_starter_nonce + th_local_index;
     uint64_t height = 0;
     difficulty_type local_diff = 0;
@@ -389,7 +392,7 @@ namespace cryptonote
       {
         //we lucky!
         ++m_config.current_extra_message_index;
-        LOG_PRINT_GREEN("Found block for difficulty: " << local_diff, LOG_LEVEL_0);
+        MGINFO_GREEN("Found block for difficulty: " << local_diff);
         if(!m_phandler->handle_block_found(b))
         {
           --m_config.current_extra_message_index;
@@ -404,7 +407,7 @@ namespace cryptonote
       ++m_hashes;
     }
     slow_hash_free_state();
-    LOG_PRINT_L0("Miner thread stopped ["<< th_local_index << "]");
+    MGINFO("Miner thread stopped ["<< th_local_index << "]");
     return true;
   }
   //-----------------------------------------------------------------------------------------------------

src/cryptonote_core/tx_pool.cpp

@@ -45,6 +45,9 @@
 #include "common/perf_timer.h"
 #include "crypto/hash.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "txpool"
+
 DISABLE_VS_WARNINGS(4244 4345 4503) //'boost::foreach_detail_::or_' : decorated name length exceeded, name was truncated
 
 namespace cryptonote

src/cryptonote_protocol/cryptonote_protocol_handler-base.cpp

@@ -73,11 +73,11 @@
 #include "../../src/cryptonote_protocol/cryptonote_protocol_handler.h"
 #include "../../src/p2p/network_throttle.hpp"
 
-#include "../../contrib/otshell_utils/utils.hpp"
-using namespace nOT::nUtils;
-
 #include "../../../src/cryptonote_core/cryptonote_core.h" // e.g. for the send_stop_signal()
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.cn"
+
 // ################################################################################################
 // ################################################################################################
 // the "header part". Not separated out for .hpp because point of this modification is 
@@ -122,25 +122,24 @@ cryptonote_protocol_handler_base::~cryptonote_protocol_handler_base() {
 
 void cryptonote_protocol_handler_base::handler_request_blocks_history(std::list<crypto::hash>& ids) {
 	using namespace epee::net_utils;
-	LOG_PRINT_L1("### ~~~RRRR~~~~ ### sending request (type 2), limit = " << ids.size());
+	MDEBUG("### ~~~RRRR~~~~ ### sending request (type 2), limit = " << ids.size());
-	LOG_PRINT_RED("RATE LIMIT NOT IMPLEMENTED HERE YET (download at unlimited speed?)" , LOG_LEVEL_1);
+	MWARNING("RATE LIMIT NOT IMPLEMENTED HERE YET (download at unlimited speed?)");
-	_note_c("net/req2", "### ~~~RRRR~~~~ ### sending request (type 2), limit = " << ids.size());
 	// TODO
 }
 
-void cryptonote_protocol_handler_base::handler_response_blocks_now(size_t packet_size) { _scope_dbg1("");
+void cryptonote_protocol_handler_base::handler_response_blocks_now(size_t packet_size) {
 	using namespace epee::net_utils;
 	double delay=0; // will be calculated
-	_dbg1("Packet size: " << packet_size);
+	MDEBUG("Packet size: " << packet_size);
 	do
 	{ // rate limiting
 		//XXX 
 		/*if (::cryptonote::core::get_is_stopping()) { 
-			_dbg1("We are stopping - so abort sleep");
+			MDEBUG("We are stopping - so abort sleep");
 			return;
 		}*/
 		/*if (m_was_shutdown) { 
-			_dbg2_c("net/netuse/sleep","m_was_shutdown - so abort sleep");
+			MDEBUG("m_was_shutdown - so abort sleep");
 			return;
 		}*/
 
@@ -155,9 +154,7 @@ void cryptonote_protocol_handler_base::handler_response_blocks_now(size_t packet
 		if (delay > 0) {
 			//delay += rand2*0.1;
             		long int ms = (long int)(delay * 1000);
-			_info_c("net/sleep", "Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // XXX debug sleep
+			MDEBUG("Sleeping for " << ms << " ms before packet_size="<<packet_size); // XXX debug sleep
-			_dbg1_c("net/sleep/", "sleep in sleep_before_packet");
-			_dbg2("Sleep for " << ms);
 			boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) ); // TODO randomize sleeps
 		}
 	} while(delay > 0);

src/cryptonote_protocol/cryptonote_protocol_handler.h

@@ -69,8 +69,6 @@ namespace cryptonote
 			
 			virtual double get_avg_block_size() = 0;
 			virtual double estimate_one_block_size() noexcept; // for estimating size of blocks to download
-
-			virtual std::ofstream& get_logreq() const =0;
 	};
 
   template<class t_core>
@@ -138,7 +136,6 @@ namespace cryptonote
     bool m_one_request = true;
     std::atomic<bool> m_stopping;
 
-		// static std::ofstream m_logreq;
     boost::mutex m_buffer_mutex;
     double get_avg_block_size();
     boost::circular_buffer<size_t> m_avg_buffer = boost::circular_buffer<size_t>(10);
@@ -161,8 +158,6 @@ namespace cryptonote
         epee::serialization::store_t_to_binary(arg, arg_buff);
         return m_p2p->relay_notify_to_all(t_parameter::ID, arg_buff, exclude_context);
       }
-
-			virtual std::ofstream& get_logreq() const ;
   };
 
 } // namespace

src/cryptonote_protocol/cryptonote_protocol_handler.inl

@@ -41,19 +41,15 @@
 
 #include "cryptonote_core/cryptonote_format_utils.h"
 #include "profile_tools.h"
-#include "../../contrib/otshell_utils/utils.hpp"
 #include "../../src/p2p/network_throttle-detail.hpp"
-#include "../../src/p2p/data_logger.hpp"
+
-using namespace nOT::nUtils;
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.cn"
 
 namespace cryptonote
 {
 
 
-// static
-// template<class t_core> std::ofstream  t_cryptonote_protocol_handler<t_core>::m_logreq("logreq.txt"); // static
-
-
 
   //-----------------------------------------------------------------------------------------------------------------------
   template<class t_core>
@@ -284,10 +280,10 @@ namespace cryptonote
 	int64_t max_block_height = max(static_cast<int64_t>(hshd.current_height),static_cast<int64_t>(m_core.get_current_blockchain_height()));
 	int64_t last_block_v1 = 1009826;
 	int64_t diff_v2 = max_block_height > last_block_v1 ? min(abs(diff), max_block_height - last_block_v1) : 0;
-    LOG_PRINT_CCONTEXT_YELLOW("Sync data returned a new top block candidate: " << m_core.get_current_blockchain_height() << " -> " << hshd.current_height
+    MCLOG(is_inital ? el::Level::Info : el::Level::Debug, "global", context <<  "Sync data returned a new top block candidate: " << m_core.get_current_blockchain_height() << " -> " << hshd.current_height
       << " [Your node is " << std::abs(diff) << " blocks (" << ((abs(diff) - diff_v2) / (24 * 60 * 60 / DIFFICULTY_TARGET_V1)) + (diff_v2 / (24 * 60 * 60 / DIFFICULTY_TARGET_V2)) << " days) "
       << (0 <= diff ? std::string("behind") : std::string("ahead"))
-      << "] " << ENDL << "SYNCHRONIZATION started", (is_inital ? LOG_LEVEL_0:LOG_LEVEL_1));
+      << "] " << ENDL << "SYNCHRONIZATION started");
     LOG_PRINT_L1("Remote blockchain height: " << hshd.current_height << ", id: " << hshd.top_id);
     context.m_state = cryptonote_connection_context::state_synchronizing;
     context.m_remote_blockchain_height = hshd.current_height;
@@ -515,12 +511,12 @@ namespace cryptonote
       // ones we received.
       if(context.m_requested_objects.size())
       {
-        LOG_PRINT_CCONTEXT_RED
+        MERROR
         (
           "NOTIFY_NEW_FLUFFY_BLOCK: peer sent the number of transaction requested"
           << ", but not the actual transactions requested"
           << ", context.m_requested_objects.size() = " << context.m_requested_objects.size() 
-          << ", dropping connection", LOG_LEVEL_0
+          << ", dropping connection"
         );
         
         m_p2p->drop_connection(context);
@@ -842,8 +838,8 @@ namespace cryptonote
 
     if(context.m_requested_objects.size())
     {
-      LOG_PRINT_CCONTEXT_RED("returned not all requested objects (context.m_requested_objects.size()="
+      MERROR("returned not all requested objects (context.m_requested_objects.size()="
-        << context.m_requested_objects.size() << "), dropping connection", LOG_LEVEL_0);
+        << context.m_requested_objects.size() << "), dropping connection");
       m_p2p->drop_connection(context);
       return 1;
     }
@@ -854,7 +850,7 @@ namespace cryptonote
       epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler(
         boost::bind(&t_core::resume_mine, &m_core));
 
-      LOG_PRINT_CCONTEXT_YELLOW( "Got NEW BLOCKS inside of " << __FUNCTION__ << ": size: " << arg.blocks.size() , LOG_LEVEL_1);
+      MLOG_YELLOW(el::Level::Debug, "Got NEW BLOCKS inside of " << __FUNCTION__ << ": size: " << arg.blocks.size());
 
       if (m_core.get_test_drop_download() && m_core.get_test_drop_download_height()) { // DISCARD BLOCKS for testing
 
@@ -913,15 +909,12 @@ namespace cryptonote
           TIME_MEASURE_FINISH(block_process_time);
           LOG_PRINT_CCONTEXT_L2("Block process time: " << block_process_time + transactions_process_time << "(" << transactions_process_time << "/" << block_process_time << ")ms");
 
-          epee::net_utils::data_logger::get_instance().add_data("calc_time", block_process_time + transactions_process_time);
-          epee::net_utils::data_logger::get_instance().add_data("block_processing", 1);
-
         } // each download block
         m_core.cleanup_handle_incoming_blocks();
 
         if (m_core.get_current_blockchain_height() > previous_height)
         {
-          LOG_PRINT_CCONTEXT_YELLOW( "Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height() , LOG_LEVEL_0);
+          MGINFO_YELLOW("Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height());
         }
       } // if not DISCARD BLOCK
 
@@ -973,7 +966,7 @@ namespace cryptonote
       auto it = context.m_needed_objects.begin();
 
       const size_t count_limit = m_core.get_block_sync_size();
-      _note_c("net/req-calc" , "Setting count_limit: " << count_limit);
+      MDEBUG("Setting count_limit: " << count_limit);
       while(it != context.m_needed_objects.end() && count < count_limit)
       {
         if( !(check_having_blocks && m_core.have_block(*it)))
@@ -1015,7 +1008,7 @@ namespace cryptonote
                            << "\r\non connection [" << epee::net_utils::print_connection_context_short(context)<< "]");
 
       context.m_state = cryptonote_connection_context::state_normal;
-      LOG_PRINT_CCONTEXT_GREEN(" SYNCHRONIZED OK", LOG_LEVEL_0);
+      MGINFO_GREEN("SYNCHRONIZED OK");
       on_connection_synchronized();
     }
     return true;
@@ -1027,7 +1020,7 @@ namespace cryptonote
     bool val_expected = false;
     if(m_synchronized.compare_exchange_strong(val_expected, true))
     {
-      LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL
+      MGINFO_GREEN(ENDL << "**********************************************************************" << ENDL
         << "You are now synchronized with the network. You may now start monero-wallet-cli." << ENDL
         << ENDL
         << "Please note, that the blockchain will be saved only after you quit the daemon with \"exit\" command or if you use \"save\" command." << ENDL
@@ -1118,12 +1111,12 @@ namespace cryptonote
       {
         if(m_core.get_testnet() && (support_flags & P2P_SUPPORT_FLAG_FLUFFY_BLOCKS))
         {
-          LOG_PRINT_CCONTEXT_YELLOW("PEER SUPPORTS FLUFFY BLOCKS - RELAYING THIN/COMPACT WHATEVER BLOCK", LOG_LEVEL_1);
+          MDEBUG("PEER SUPPORTS FLUFFY BLOCKS - RELAYING THIN/COMPACT WHATEVER BLOCK");
           fluffyConnections.push_back(context.m_connection_id);
         }
         else
         {
-          LOG_PRINT_CCONTEXT_YELLOW("PEER DOESN'T SUPPORT FLUFFY BLOCKS - RELAYING FULL BLOCK", LOG_LEVEL_1);
+          MDEBUG("PEER DOESN'T SUPPORT FLUFFY BLOCKS - RELAYING FULL BLOCK");
           fullConnections.push_back(context.m_connection_id);
         }
       }
@@ -1146,18 +1139,6 @@ namespace cryptonote
     return relay_post_notify<NOTIFY_NEW_TRANSACTIONS>(arg, exclude_context);
   }
 
-  /// @deprecated
-  template<class t_core> std::ofstream& t_cryptonote_protocol_handler<t_core>::get_logreq() const {
-    static std::ofstream * logreq=NULL;
-    if (!logreq) {
-      LOG_PRINT_RED("LOG OPENED",LOG_LEVEL_0);
-      logreq = new std::ofstream("logreq.txt"); // leak mem (singleton)
-      *logreq << "Opened log" << std::endl;
-    }
-    LOG_PRINT_YELLOW("LOG USED",LOG_LEVEL_0);
-    (*logreq) << "log used" << std::endl;
-    return *logreq;
-  }
   //------------------------------------------------------------------------------------------------------------------------
   template<class t_core>
   void t_cryptonote_protocol_handler<t_core>::stop()

src/daemon/CMakeLists.txt

@@ -89,7 +89,6 @@ target_link_libraries(daemon
     cryptonote_core
     crypto
     common
-    otshell_utils
     p2p
     cryptonote_protocol
     daemonizer

src/daemon/command_line_args.h

@@ -46,10 +46,10 @@ namespace daemon_args
   , "Specify log file"
   , ""
   };
-  const command_line::arg_descriptor<int> arg_log_level = {
+  const command_line::arg_descriptor<std::string> arg_log_level = {
     "log-level"
   , ""
-  , LOG_LEVEL_0
+  , ""
   };
   const command_line::arg_descriptor<std::vector<std::string>> arg_command = {
     "daemon_command"

src/daemon/command_parser_executor.cpp

@@ -29,6 +29,9 @@
 #include "common/dns_utils.h"
 #include "daemon/command_parser_executor.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize {
 
 t_command_parser_executor::t_command_parser_executor(
@@ -117,25 +120,25 @@ bool t_command_parser_executor::set_log_level(const std::vector<std::string>& ar
 {
   if(args.size() != 1)
   {
-    std::cout << "use: set_log <log_level_number_0-4>" << std::endl;
+    std::cout << "use: set_log [<log_level_number_0-4> | <categories>]" << std::endl;
     return true;
   }
 
   uint16_t l = 0;
-  if(!epee::string_tools::get_xtype_from_string(l, args[0]))
+  if(epee::string_tools::get_xtype_from_string(l, args[0]))
   {
-    std::cout << "wrong number format, use: set_log <log_level_number_0-4>" << std::endl;
+    if(4 < l)
-    return true;
-  }
-
-  if(LOG_LEVEL_4 < l)
     {
       std::cout << "wrong number range, use: set_log <log_level_number_0-4>" << std::endl;
       return true;
     }
-
     return m_executor.set_log_level(l);
   }
+  else
+  {
+    return m_executor.set_log_categories(args.front());
+  }
+}
 
 bool t_command_parser_executor::print_height(const std::vector<std::string>& args) 
 {

src/daemon/command_parser_executor.h

@@ -72,6 +72,8 @@ public:
 
   bool set_log_level(const std::vector<std::string>& args);
 
+  bool set_log_categories(const std::vector<std::string>& args);
+
   bool print_height(const std::vector<std::string>& args);
 
   bool print_block(const std::vector<std::string>& args);

src/daemon/command_server.cpp

@@ -30,6 +30,9 @@
 #include "version.h"
 #include "daemon/command_server.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize {
 
 namespace p = std::placeholders;
@@ -133,7 +136,7 @@ t_command_server::t_command_server(
   m_command_lookup.set_handler(
       "set_log"
     , std::bind(&t_command_parser_executor::set_log_level, &m_parser, p::_1)
-    , "set_log <level> - Change current log detalization level, <level> is a number 0-4"
+    , "set_log <level>|<categories> - Change current loglevel, <level> is a number 0-4"
     );
   m_command_lookup.set_handler(
       "diff"

src/daemon/core.h

@@ -33,6 +33,9 @@
 #include "misc_log_ex.h"
 #include "daemon/command_line_args.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize
 {
 
@@ -68,12 +71,12 @@ public:
   bool run()
   {
     //initialize core here
-    LOG_PRINT_L0("Initializing core...");
+    MGINFO("Initializing core...");
     if (!m_core.init(m_vm_HACK))
     {
       return false;
     }
-    LOG_PRINT_L0("Core initialized OK");
+    MGINFO("Core initialized OK");
     return true;
   }
 
@@ -84,12 +87,12 @@ public:
 
   ~t_core()
   {
-    LOG_PRINT_L0("Deinitializing core...");
+    MGINFO("Deinitializing core...");
     try {
       m_core.deinit();
       m_core.set_cryptonote_protocol(nullptr);
     } catch (...) {
-      LOG_PRINT_L0("Failed to deinitialize core...");
+      MERROR("Failed to deinitialize core...");
     }
   }
 };

src/daemon/daemon.cpp

@@ -46,6 +46,9 @@ using namespace epee;
 
 #include <functional>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize {
 
 struct t_internals {
@@ -136,17 +139,17 @@ bool t_daemon::run(bool interactive)
     }
 
     mp_internals->rpc.stop();
-    LOG_PRINT("Node stopped.", LOG_LEVEL_0);
+    MGINFO("Node stopped.");
     return true;
   }
   catch (std::exception const & ex)
   {
-    LOG_ERROR("Uncaught exception! " << ex.what());
+    MFATAL("Uncaught exception! " << ex.what());
     return false;
   }
   catch (...)
   {
-    LOG_ERROR("Uncaught exception!");
+    MFATAL("Uncaught exception!");
     return false;
   }
 }

src/daemon/daemon.h

@@ -29,6 +29,9 @@
 #pragma once
 #include <boost/program_options.hpp>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize {
 
 struct t_internals;

src/daemon/executor.cpp

@@ -26,16 +26,19 @@
 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "daemon/executor.h"
-
 #include "misc_log_ex.h"
 
+#include "daemon/executor.h"
+
 #include "common/command_line.h"
 #include "cryptonote_config.h"
 #include "version.h"
 
 #include <string>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize
 {
   std::string const t_executor::NAME = "Monero Daemon";
@@ -64,7 +67,6 @@ namespace daemonize
       boost::program_options::variables_map const & vm
     )
   {
-    epee::log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL);
     return t_daemon{vm}.run(true);
   }
 }

src/daemon/executor.h

@@ -34,6 +34,9 @@
 #include <string>
 #include <vector>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize
 {
   class t_executor final

src/daemon/main.cpp

@@ -47,6 +47,9 @@
 #include "common/stack_trace.h"
 #endif // STACK_TRACE
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace po = boost::program_options;
 namespace bf = boost::filesystem;
 
@@ -54,7 +57,6 @@ int main(int argc, char const * argv[])
 {
   try {
 
-    _note_c("dbg/main", "Begin of main()");
     // TODO parse the debug options like set log level right here at start
 
     tools::sanitize_locale();
@@ -79,7 +81,6 @@ int main(int argc, char const * argv[])
       bf::path default_conf = default_data_dir / std::string(CRYPTONOTE_NAME ".conf");
       command_line::add_arg(visible_options, daemon_args::arg_config_file, default_conf.string());
       command_line::add_arg(visible_options, command_line::arg_test_dbg_lock_sleep);
-      cryptonote::core::init_options(core_settings);
 
       // Settings
       bf::path default_log = default_data_dir / std::string(CRYPTONOTE_NAME ".log");
@@ -196,6 +197,23 @@ int main(int argc, char const * argv[])
     }
     po::notify(vm);
 
+    // log_file_path
+    //   default: <data_dir>/<CRYPTONOTE_NAME>.log
+    //   if log-file argument given:
+    //     absolute path
+    //     relative path: relative to data_dir
+    bf::path log_file_path {data_dir / std::string(CRYPTONOTE_NAME ".log")};
+    if (! vm["log-file"].defaulted())
+      log_file_path = command_line::get_arg(vm, daemon_args::arg_log_file);
+    log_file_path = bf::absolute(log_file_path, relative_path_base);
+    mlog_configure(log_file_path.string(), true);
+
+    // Set log level
+    if (!vm["log-level"].defaulted())
+    {
+      mlog_set_log(command_line::get_arg(vm, daemon_args::arg_log_level).c_str());
+    }
+
     // If there are positional options, we're running a daemon command
     {
       auto command = command_line::get_arg(vm, daemon_args::arg_command);
@@ -236,55 +254,17 @@ int main(int argc, char const * argv[])
       }
     }
 
-    // Start with log level 0
-    epee::log_space::get_set_log_detalisation_level(true, LOG_LEVEL_0);
-
-    // Set log level
-    {
-      int new_log_level = command_line::get_arg(vm, daemon_args::arg_log_level);
-      if(new_log_level < LOG_LEVEL_MIN || new_log_level > LOG_LEVEL_MAX)
-      {
-        LOG_PRINT_L0("Wrong log level value: " << new_log_level);
-      }
-      else if (epee::log_space::get_set_log_detalisation_level(false) != new_log_level)
-      {
-        epee::log_space::get_set_log_detalisation_level(true, new_log_level);
-        int otshell_utils_log_level = 100 - (new_log_level * 20);
-        gCurrentLogger.setDebugLevel(otshell_utils_log_level);
-        LOG_PRINT_L0("LOG_LEVEL set to " << new_log_level);
-      }
-    }
-
-    // log_file_path
-    //   default: <data_dir>/<CRYPTONOTE_NAME>.log
-    //   if log-file argument given:
-    //     absolute path
-    //     relative path: relative to data_dir
-
-    // Set log file
-    {
-      bf::path log_file_path {data_dir / std::string(CRYPTONOTE_NAME ".log")};
-      if (! vm["log-file"].defaulted())
-        log_file_path = command_line::get_arg(vm, daemon_args::arg_log_file);
-      log_file_path = bf::absolute(log_file_path, relative_path_base);
-
-      epee::log_space::log_singletone::add_logger(
-          LOGGER_FILE
-        , log_file_path.filename().string().c_str()
-        , log_file_path.parent_path().string().c_str()
-        );
 #ifdef STACK_TRACE
     tools::set_stack_trace_log(log_file_path.filename().string());
 #endif // STACK_TRACE
-    }
 
     if (command_line::has_arg(vm, daemon_args::arg_max_concurrency))
       tools::set_max_concurrency(command_line::get_arg(vm, daemon_args::arg_max_concurrency));
 
     // logging is now set up
-    LOG_PRINT_L0("Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")");
+    MGINFO("Monero '" << MONERO_RELEASE_NAME << "' (v" << MONERO_VERSION_FULL << ")");
 
-    _note_c("dbg/main", "Moving from main() into the daemonize now.");
+    MINFO("Moving from main() into the daemonize now.");
 
     return daemonizer::daemonize(argc, argv, daemonize::t_executor{}, vm);
   }

src/daemon/p2p.h

@@ -34,6 +34,9 @@
 #include "p2p/net_node.h"
 #include "daemon/protocol.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize
 {
 
@@ -57,12 +60,12 @@ public:
     : m_server{protocol.get()}
   {
     //initialize objects
-    LOG_PRINT_L0("Initializing p2p server...");
+    MGINFO("Initializing p2p server...");
     if (!m_server.init(vm))
     {
       throw std::runtime_error("Failed to initialize p2p server.");
     }
-    LOG_PRINT_L0("P2p server initialized OK");
+    MGINFO("P2p server initialized OK");
   }
 
   t_node_server & get()
@@ -72,9 +75,9 @@ public:
 
   void run()
   {
-    LOG_PRINT_L0("Starting p2p net loop...");
+    MGINFO("Starting p2p net loop...");
     m_server.run();
-    LOG_PRINT_L0("p2p net loop stopped");
+    MGINFO("p2p net loop stopped");
   }
 
   void stop()
@@ -84,11 +87,11 @@ public:
 
   ~t_p2p()
   {
-    LOG_PRINT_L0("Deinitializing p2p...");
+    MGINFO("Deinitializing p2p...");
     try {
       m_server.deinit();
     } catch (...) {
-      LOG_PRINT_L0("Failed to deinitialize p2p...");
+      MERROR("Failed to deinitialize p2p...");
     }
   }
 };

src/daemon/protocol.h

@@ -30,6 +30,9 @@
 
 #pragma once
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize
 {
 
@@ -47,12 +50,12 @@ public:
     )
     : m_protocol{core.get(), nullptr}
   {
-    LOG_PRINT_L0("Initializing cryptonote protocol...");
+    MGINFO("Initializing cryptonote protocol...");
     if (!m_protocol.init(vm))
     {
       throw std::runtime_error("Failed to initialize cryptonote protocol.");
     }
-    LOG_PRINT_L0("Cryptonote protocol initialized OK");
+    MGINFO("Cryptonote protocol initialized OK");
   }
 
   t_protocol_raw & get()
@@ -69,11 +72,11 @@ public:
 
   ~t_protocol()
   {
-    LOG_PRINT_L0("Stopping cryptonote protocol...");
+    MGINFO("Stopping cryptonote protocol...");
     try {
       m_protocol.deinit();
       m_protocol.set_p2p_endpoint(nullptr);
-      LOG_PRINT_L0("Cryptonote protocol stopped successfully");
+      MGINFO("Cryptonote protocol stopped successfully");
     } catch (...) {
       LOG_ERROR("Failed to stop cryptonote protocol!");
     }

src/daemon/rpc.h

@@ -32,6 +32,9 @@
 
 #include "rpc/core_rpc_server.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize
 {
 
@@ -52,27 +55,27 @@ public:
     )
     : m_server{core.get(), p2p.get()}
   {
-    LOG_PRINT_L0("Initializing core rpc server...");
+    MGINFO("Initializing core rpc server...");
     if (!m_server.init(vm))
     {
       throw std::runtime_error("Failed to initialize core rpc server.");
     }
-    LOG_PRINT_GREEN("Core rpc server initialized OK on port: " << m_server.get_binded_port(), LOG_LEVEL_0);
+    MGINFO("Core rpc server initialized OK on port: " << m_server.get_binded_port());
   }
 
   void run()
   {
-    LOG_PRINT_L0("Starting core rpc server...");
+    MGINFO("Starting core rpc server...");
     if (!m_server.run(2, false))
     {
       throw std::runtime_error("Failed to start core rpc server.");
     }
-    LOG_PRINT_L0("Core rpc server started ok");
+    MGINFO("Core rpc server started ok");
   }
 
   void stop()
   {
-    LOG_PRINT_L0("Stopping core rpc server...");
+    MGINFO("Stopping core rpc server...");
     m_server.send_stop_signal();
     m_server.timed_wait_server_stop(5000);
   }
@@ -84,11 +87,11 @@ public:
 
   ~t_rpc()
   {
-    LOG_PRINT_L0("Deinitializing rpc server...");
+    MGINFO("Deinitializing rpc server...");
     try {
       m_server.deinit();
     } catch (...) {
-      LOG_PRINT_L0("Failed to deinitialize rpc server...");
+      MERROR("Failed to deinitialize rpc server...");
     }
   }
 };

src/daemon/rpc_command_executor.cpp

@@ -38,6 +38,9 @@
 #include <ctime>
 #include <string>
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize {
 
 namespace {
@@ -517,6 +520,34 @@ bool t_rpc_command_executor::set_log_level(int8_t level) {
   return true;
 }
 
+bool t_rpc_command_executor::set_log_categories(const std::string &categories) {
+  cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES::request req;
+  cryptonote::COMMAND_RPC_SET_LOG_CATEGORIES::response res;
+  req.categories = categories;
+
+  std::string fail_message = "Unsuccessful";
+
+  if (m_is_rpc)
+  {
+    if (!m_rpc_client->rpc_request(req, res, "/set_log_categories", fail_message.c_str()))
+    {
+      return true;
+    }
+  }
+  else
+  {
+    if (!m_rpc_server->on_set_log_categories(req, res) || res.status != CORE_RPC_STATUS_OK)
+    {
+      tools::fail_msg_writer() << fail_message.c_str();
+      return true;
+    }
+  }
+
+  tools::success_msg_writer() << "Log categories are now " << categories;
+
+  return true;
+}
+
 bool t_rpc_command_executor::print_height() {
   cryptonote::COMMAND_RPC_GET_HEIGHT::request req;
   cryptonote::COMMAND_RPC_GET_HEIGHT::response res;

src/daemon/rpc_command_executor.h

@@ -45,6 +45,9 @@
 #include "p2p/net_node.h"
 #include "rpc/core_rpc_server.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
+
 namespace daemonize {
 
 class t_rpc_command_executor final {
@@ -82,6 +85,8 @@ public:
 
   bool set_log_level(int8_t level);
 
+  bool set_log_categories(const std::string &categories);
+
   bool print_height();
 
   bool print_block_by_hash(crypto::hash block_hash);

src/p2p/connection_basic.cpp

@@ -77,14 +77,13 @@
 #include <boost/asio/ip/unicast.hpp>
 #include "../../contrib/epee/include/net/abstract_tcp_server2.h"
 
-#include "../../contrib/otshell_utils/utils.hpp"
-#include "data_logger.hpp"
-using namespace nOT::nUtils;
-
 // TODO:
 #include "../../src/p2p/network_throttle-detail.hpp"
 #include "../../src/cryptonote_core/cryptonote_core.h"
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.p2p"
+
 // ################################################################################################
 // local (TU local) headers
 // ################################################################################################
@@ -219,19 +218,6 @@ uint64_t connection_basic::get_rate_down_limit() {
 }
 
 void connection_basic::save_limit_to_file(int limit) {
-    // saving limit to file
-    if (!epee::net_utils::data_logger::m_save_graph)
-		return;
-
-    {
-         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_out );
-               epee::net_utils::data_logger::get_instance().add_data("upload_limit", network_throttle_manager::get_global_throttle_out().get_target_speed() / 1024);
-	}
-	
-    {
-         CRITICAL_REGION_LOCAL(        network_throttle_manager::m_lock_get_global_throttle_in );
-               epee::net_utils::data_logger::get_instance().add_data("download_limit", network_throttle_manager::get_global_throttle_in().get_target_speed() / 1024);
-	}
 }
  
 void connection_basic::set_tos_flag(int tos) {
@@ -259,9 +245,8 @@ void connection_basic::sleep_before_packet(size_t packet_size, int phase,  int q
 		delay *= 0.50;
 		if (delay > 0) {
             long int ms = (long int)(delay * 1000);
-			_info_c("net/sleep", "Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // debug sleep
+			MDEBUG("Sleeping in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<packet_size); // debug sleep
 			_dbg1("sleep in sleep_before_packet");
-			epee::net_utils::data_logger::get_instance().add_data("sleep_up", ms);
 			boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) );
 		}
 	} while(delay > 0);
@@ -280,25 +265,21 @@ void connection_basic::set_start_time() {
 
 void connection_basic::do_send_handler_write(const void* ptr , size_t cb ) {
 	sleep_before_packet(cb,1,-1);
-	_info_c("net/out/size", "handler_write (direct) - before ASIO write, for packet="<<cb<<" B (after sleep)");
+	MDEBUG("handler_write (direct) - before ASIO write, for packet="<<cb<<" B (after sleep)");
 	set_start_time();
 }
 
 void connection_basic::do_send_handler_write_from_queue( const boost::system::error_code& e, size_t cb, int q_len ) {
 	sleep_before_packet(cb,2,q_len);
-	_info_c("net/out/size", "handler_write (after write, from queue="<<q_len<<") - before ASIO write, for packet="<<cb<<" B (after sleep)");
+	MDEBUG("handler_write (after write, from queue="<<q_len<<") - before ASIO write, for packet="<<cb<<" B (after sleep)");
 
 	set_start_time();
 }
 
 void connection_basic::logger_handle_net_read(size_t size) { // network data read
-    size /= 1024;
-    epee::net_utils::data_logger::get_instance().add_data("download", size);
 }
 
 void connection_basic::logger_handle_net_write(size_t size) {
-    size /= 1024;
-    epee::net_utils::data_logger::get_instance().add_data("upload", size);	
 }
 
 double connection_basic::get_sleep_time(size_t cb) {
@@ -308,7 +289,6 @@ double connection_basic::get_sleep_time(size_t cb) {
 }
 
 void connection_basic::set_save_graph(bool save_graph) {
-	epee::net_utils::data_logger::m_save_graph = save_graph;
 }
 
 

src/p2p/data_logger.cpp

@@ -1,202 +0,0 @@
-// Copyright (c) 2014-2016, The Monero Project
-// 
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-// 
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include "data_logger.hpp"
-#include <stdexcept>
-
-#include <boost/chrono.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/thread.hpp>
-#include <chrono>
-#include "../../contrib/otshell_utils/utils.hpp"
-
-namespace epee
-{
-namespace net_utils
-{
-	data_logger &data_logger::get_instance() {
-		boost::call_once(m_singleton, 
-			[] { 
-				_info_c("dbg/data","Creating singleton of data_logger");
-				if (m_state != data_logger_state::state_before_init) { _erro_c("dbg/data","Internal error in singleton"); throw std::runtime_error("data_logger singleton"); }
-				m_state = data_logger_state::state_during_init;
-				m_obj.reset(new data_logger());
-				m_state = data_logger_state::state_ready_to_use;
-			}	
-		);
-		
-		if (m_state != data_logger_state::state_ready_to_use) {
-			_erro ("trying to use not working data_logger");
-			throw std::runtime_error("data_logger ctor state");
-		}
-		
-		return * m_obj;
-	}
-	
-	data_logger::data_logger() {
-		_note_c("dbg/data","Starting data logger (for graphs data)");
-		if (m_state != data_logger_state::state_during_init) { _erro_c("dbg/data","Singleton ctor state"); throw std::runtime_error("data_logger ctor state"); }
-		boost::lock_guard<boost::mutex> lock(mMutex); // lock
-		
-		// prepare all the files for given data channels:
-		mFilesMap["peers"] = data_logger::fileData("log/dr-monero/peers.data");
-		mFilesMap["download"] = data_logger::fileData("log/dr-monero/net/in-all.data");
-		mFilesMap["upload"] = data_logger::fileData("log/dr-monero/net/out-all.data");
-		mFilesMap["request"] = data_logger::fileData("log/dr-monero/net/req-all.data");
-		mFilesMap["sleep_down"] = data_logger::fileData("log/dr-monero/down_sleep_log.data");
-		mFilesMap["sleep_up"] = data_logger::fileData("log/dr-monero/up_sleep_log.data");
-		mFilesMap["calc_time"] = data_logger::fileData("log/dr-monero/get_objects_calc_time.data");
-		mFilesMap["blockchain_processing_time"] = data_logger::fileData("log/dr-monero/blockchain_log.data");
-		mFilesMap["block_processing"] = data_logger::fileData("log/dr-monero/block_proc.data");
-		
-		mFilesMap["peers_limit"] = data_logger::fileData("log/dr-monero/peers_limit.info");
-		mFilesMap["download_limit"] = data_logger::fileData("log/dr-monero/limit_down.info");
-		mFilesMap["upload_limit"] = data_logger::fileData("log/dr-monero/limit_up.info");
-		
-		mFilesMap["peers_limit"].mLimitFile = true;
-		mFilesMap["download_limit"].mLimitFile = true;
-		mFilesMap["upload_limit"].mLimitFile = true;
-
-		// do NOT modify mFilesMap below this point, since there is no locking for this used (yet)
-
-		_info_c("dbg/data","Creating thread for data logger"); // create timer thread
-		m_thread_maybe_running=true;
-		std::shared_ptr<boost::thread> logger_thread(new boost::thread([&]() {
-			_info_c("dbg/data","Inside thread for data logger");
-			while (m_state == data_logger_state::state_during_init) { // wait for creation to be done (in other thread, in singleton) before actually running
-				boost::this_thread::sleep_for(boost::chrono::seconds(1));
-			}
-			_info_c("dbg/data","Inside thread for data logger - going into main loop");
-			while (m_state == data_logger_state::state_ready_to_use) { // run as long as we are not closing the single object
-				boost::this_thread::sleep_for(boost::chrono::seconds(1));
-				saveToFile(); // save all the pending data
-			}
-			_info_c("dbg/data","Inside thread for data logger - done the main loop");
-			m_thread_maybe_running=false;
-		}));
-		logger_thread->detach();
-		_info_c("dbg/data","Data logger constructed");
-	}
-
-	data_logger::~data_logger() noexcept(false) {
-		_note_c("dbg/data","Destructor of the data logger");
-		{
-			boost::lock_guard<boost::mutex> lock(mMutex);
-			m_state = data_logger_state::state_dying;
-		}
-		_info_c("dbg/data","State was set to dying");
-		while(m_thread_maybe_running) { // wait for the thread to exit
-			boost::this_thread::sleep_for(boost::chrono::seconds(1));
-			_info_c("dbg/data","Waiting for background thread to exit");
-		}
-		_info_c("dbg/data","Thread exited");
-	}
-
-	void data_logger::kill_instance() { 
-		m_state = data_logger_state::state_dying;
-		m_obj.reset();
-	}
-	
-	void data_logger::add_data(std::string filename, unsigned int data) {
-		boost::lock_guard<boost::mutex> lock(mMutex);
-		if (m_state != data_logger_state::state_ready_to_use) { _info_c("dbg/data","Data logger is not ready, returning."); return; }
-
-		if (mFilesMap.find(filename) == mFilesMap.end()) { // no such file/counter
-			_erro_c("dbg/data","Trying to use not opened data file filename="<<filename);
-			_erro_c("dbg/data","Disabling saving of graphs due to error");
-			m_save_graph=false; // <--- disabling saving graphs
-			return;
-		}
-		
-		if (mFilesMap[filename].mLimitFile) { // this holds a number (that is not additive) - e.g. the limit setting
-			mFilesMap[filename].mDataToSave = data;
-		} else {
-			mFilesMap[filename].mDataToSave += data; // this holds a number that should be sum of all accumulated samples
-		}
-	}
-	
-	bool data_logger::is_dying() {
-		if (m_state == data_logger_state::state_dying) {
-			return true;
-		}
-		else {
-			return false;
-		}
-	}
-
-	void data_logger::saveToFile() {
-		_dbg2_c("dbg/data","saving to files");
-		boost::lock_guard<boost::mutex> lock(mMutex);
-		if (m_state != data_logger_state::state_ready_to_use) { _info_c("dbg/data","Data logger is not ready, returning."); return; }
-		nOT::nUtils::cFilesystemUtils::CreateDirTree("log/dr-monero/net/");
-		for (auto &element : mFilesMap)
-		{
-			element.second.save();
-			if (!element.second.mLimitFile) element.second.mDataToSave = 0;
-		}
-	}
-
-	// the inner class:
-	
-	double data_logger::fileData::get_current_time() {
-		#if defined(__APPLE__)
-		auto point = std::chrono::system_clock::now();
-		#else
-		auto point = std::chrono::steady_clock::now();
-		#endif
-		auto time_from_epoh = point.time_since_epoch();
-		auto ms = std::chrono::duration_cast< std::chrono::milliseconds >( time_from_epoh ).count();
-		double ms_f = ms;
-		return ms_f / 1000.;
-	}
-	
-	data_logger::fileData::fileData(std::string pFile) {
-		_dbg3_c("dbg/data","opening data file named pFile="<<pFile<<" for this="<<this);
-		mFile = std::make_shared<std::ofstream> (pFile);
-		_dbg1_c("dbg/data","opened data file named pFile="<<pFile<<" in mFile="<<mFile<<" for this="<<this);
-		mPath = pFile;
-	}
-	
-	void data_logger::fileData::save() {
-		if (!data_logger::m_save_graph) return; // <--- disabled
-		_dbg2_c("dbg/data","saving to the file now, mFile="<<mFile);
-		mFile->open(mPath, std::ios::app);
-		*mFile << static_cast<int>(get_current_time()) << " " << mDataToSave << std::endl;
-		mFile->close();
-	}
-	
-	
-data_logger_state data_logger::m_state(data_logger_state::state_before_init); ///< (static) state of the singleton object
-std::atomic<bool> data_logger::m_save_graph(false); // (static)
-std::atomic<bool> data_logger::m_thread_maybe_running(false); // (static)
-boost::once_flag data_logger::m_singleton; // (static)
-std::unique_ptr<data_logger> data_logger::m_obj; // (static)
-
-} // namespace
-} // namespace
-

src/p2p/data_logger.hpp

@@ -1,105 +0,0 @@
-// Copyright (c) 2014-2016, The Monero Project
-// 
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-// 
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-// 
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef INCLUDED_p2p_data_logger_hpp
-#define INCLUDED_p2p_data_logger_hpp
-
-#include <string>
-#include <map>
-#include <fstream>
-#include <memory>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/once.hpp>
-#include <atomic>
-
-namespace epee
-{
-namespace net_utils
-{
-
-enum class data_logger_state { state_before_init, state_during_init, state_ready_to_use, state_dying };
-	
-/***
-@note: use it ONLY via singleton! It will be spawned then, and will auto destruct on program exit.
-@note: do call ::kill_instance() before exiting main, at end of main. But before make sure no one else (e.g. no other threads) will try to use this/singleton
-@note: it is not allowed to use this class from code "runnig before or after main", e.g. from ctors of static objects, because of static-creation-order races
-@note: on creation (e.g. from singleton), it spawns a thread that saves all data in background
-*/
-	class data_logger {
-		public:
-			static data_logger &get_instance(); ///< singleton
-			static void kill_instance(); ///< call this before ending main to allow more gracefull shutdown of the main singleton and it's background thread
-			~data_logger() noexcept(false); ///< destr, will be called when singleton is killed when global m_obj dies. will kill theads etc
-
-		private:
-			data_logger(); ///< constructor is private, use only via singleton get_instance
-
-		public:
-			data_logger(const data_logger &ob) = delete; // use only one per program
-			data_logger(data_logger &&ob) = delete;
-			data_logger & operator=(const data_logger&) = delete;
-			data_logger & operator=(data_logger&&) = delete;
-
-			void add_data(std::string filename, unsigned int data); ///< use this to append data here. Use it only the singleton. It locks itself.
-
-			static std::atomic<bool> m_save_graph; ///< global setting flag, should we save all the data or not (can disable logging graphs data)
-			static bool is_dying();
-
-		private:
-			static boost::once_flag m_singleton; ///< to guarantee singleton creates the object exactly once
-			static data_logger_state m_state; ///< state of the singleton object
-			static std::atomic<bool> m_thread_maybe_running; ///< is the background thread (more or less) running, or is it fully finished
-			static std::unique_ptr<data_logger> m_obj; ///< the singleton object. Only use it via get_instance(). Can be killed by kill_instance()
-
-			/***
-			* one graph/file with data
-			*/
-			class fileData {
-				public:
-					fileData() = default;
-					fileData(const fileData &ob) = delete;
-					fileData(std::string pFile);
-					
-					std::shared_ptr<std::ofstream> mFile;
-					long int mDataToSave = 0; ///< sum of the data (in current interval, will be counted from 0 on next interval)
-					static double get_current_time();
-					void save();
-					std::string mPath;
-					bool mLimitFile = false; ///< this holds a number (that is not additive) - e.g. the limit setting
-			};
-			
-			std::map<std::string, fileData> mFilesMap;
-			boost::mutex mMutex;
-			void saveToFile(); ///< write data to the target files. do not use this directly
-	};
-	
-} // namespace
-} // namespace
-
-#endif

src/p2p/net_node.inl

@@ -48,7 +48,6 @@
 #include "net/local_ip.h"
 #include "crypto/crypto.h"
 #include "storages/levin_abstract_invoke2.h"
-#include "data_logger.hpp"
 
 // We have to look for miniupnpc headers in different places, dependent on if its compiled or external
 #ifdef UPNP_STATIC
@@ -61,6 +60,9 @@
   #include "upnperrors.h"
 #endif
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "net.p2p"
+
 #define NET_MAKE_IP(b1,b2,b3,b4)  ((LPARAM)(((DWORD)(b1)<<24)+((DWORD)(b2)<<16)+((DWORD)(b3)<<8)+((DWORD)(b4))))
 
 
@@ -203,7 +205,7 @@ namespace nodetool
     if(time(nullptr) >= it->second)
     {
       m_blocked_ips.erase(it);
-      LOG_PRINT_CYAN("IP " << epee::string_tools::get_ip_string_from_int32(addr) << " unblocked.", LOG_LEVEL_0);
+      MLOG_CYAN(el::Level::Info, "IP " << epee::string_tools::get_ip_string_from_int32(addr) << " unblocked.");
       return true;
     }
     return false;
@@ -235,7 +237,7 @@ namespace nodetool
     for (const auto &c: conns)
       m_net_server.get_config_object().close(c);
 
-    LOG_PRINT_CYAN("IP " << epee::string_tools::get_ip_string_from_int32(addr) << " blocked.", LOG_LEVEL_0);
+    MLOG_CYAN(el::Level::Info, "IP " << epee::string_tools::get_ip_string_from_int32(addr) << " blocked.");
     return true;
   }
   //-----------------------------------------------------------------------------------
@@ -247,7 +249,7 @@ namespace nodetool
     if (i == m_blocked_ips.end())
       return false;
     m_blocked_ips.erase(i);
-    LOG_PRINT_CYAN("IP " << epee::string_tools::get_ip_string_from_int32(addr) << " unblocked.", LOG_LEVEL_0);
+    MLOG_CYAN(el::Level::Info, "IP " << epee::string_tools::get_ip_string_from_int32(addr) << " unblocked.");
     return true;
   }
   //-----------------------------------------------------------------------------------
@@ -256,7 +258,7 @@ namespace nodetool
   {
     CRITICAL_REGION_LOCAL(m_ip_fails_score_lock);
     uint64_t fails = ++m_ip_fails_score[address];
-    LOG_PRINT_CYAN("IP " << epee::string_tools::get_ip_string_from_int32(address) << " fail score=" << fails, LOG_LEVEL_1);
+    MDEBUG("IP " << epee::string_tools::get_ip_string_from_int32(address) << " fail score=" << fails);
     if(fails > P2P_IP_FAILS_BEFORE_BLOCK)
     {
       auto it = m_ip_fails_score.find(address);
@@ -376,11 +378,11 @@ namespace nodetool
         na.ip = boost::asio::detail::socket_ops::host_to_network_long(endpoint.address().to_v4().to_ulong());
         na.port = endpoint.port();
         seed_nodes.push_back(na);
-        LOG_PRINT_L4("Added seed node: " << endpoint.address().to_v4().to_string(ec) << ':' << na.port);
+        MINFO("Added seed node: " << endpoint.address().to_v4().to_string(ec) << ':' << na.port);
       }
       else
       {
-        LOG_PRINT_L2("IPv6 doesn't supported, skip '" << host << "' -> " << endpoint.address().to_v6().to_string(ec));
+        MDEBUG("IPv6 doesn't supported, skip '" << host << "' -> " << endpoint.address().to_v6().to_string(ec));
       }
     }
   }
@@ -416,7 +418,7 @@ namespace nodetool
       {
         boost::thread* th = new boost::thread([=, &dns_results, &addr_str]
         {
-          LOG_PRINT_L4("dns_threads[" << result_index << "] created for: " << addr_str);
+          MDEBUG("dns_threads[" << result_index << "] created for: " << addr_str);
           // TODO: care about dnssec avail/valid
           bool avail, valid;
           std::vector<std::string> addr_list;
@@ -424,7 +426,7 @@ namespace nodetool
           try
           {
             addr_list = tools::DNSResolver::instance().get_ipv4(addr_str, avail, valid);
-            LOG_PRINT_L4("dns_threads[" << result_index << "] DNS resolve done");
+            MDEBUG("dns_threads[" << result_index << "] DNS resolve done");
             boost::this_thread::interruption_point();
           }
           catch(const boost::thread_interrupted&)
@@ -432,11 +434,11 @@ namespace nodetool
             // thread interruption request
             // even if we now have results, finish thread without setting
             // result variables, which are now out of scope in main thread
-            LOG_PRINT_L4("dns_threads[" << result_index << "] interrupted");
+            MWARNING("dns_threads[" << result_index << "] interrupted");
             return;
           }
 
-          LOG_PRINT_L4("dns_threads[" << result_index << "] addr_str: " << addr_str << "  number of results: " << addr_list.size());
+          MINFO("dns_threads[" << result_index << "] addr_str: " << addr_str << "  number of results: " << addr_list.size());
           dns_results[result_index] = addr_list;
         });
 
@@ -444,14 +446,14 @@ namespace nodetool
         ++result_index;
       }
 
-      LOG_PRINT_L4("dns_threads created, now waiting for completion or timeout of " << CRYPTONOTE_DNS_TIMEOUT_MS << "ms");
+      MDEBUG("dns_threads created, now waiting for completion or timeout of " << CRYPTONOTE_DNS_TIMEOUT_MS << "ms");
       boost::chrono::system_clock::time_point deadline = boost::chrono::system_clock::now() + boost::chrono::milliseconds(CRYPTONOTE_DNS_TIMEOUT_MS);
       uint64_t i = 0;
       for (boost::thread* th : dns_threads)
       {
         if (! th->try_join_until(deadline))
         {
-          LOG_PRINT_L4("dns_threads[" << i << "] timed out, sending interrupt");
+          MWARNING("dns_threads[" << i << "] timed out, sending interrupt");
           th->interrupt();
         }
         ++i;
@@ -460,7 +462,7 @@ namespace nodetool
       i = 0;
       for (const auto& result : dns_results)
       {
-        LOG_PRINT_L4("DNS lookup for " << m_seed_nodes_list[i] << ": " << result.size() << " results");
+        MDEBUG("DNS lookup for " << m_seed_nodes_list[i] << ": " << result.size() << " results");
         // if no results for node, thread's lookup likely timed out
         if (result.size())
         {
@@ -472,7 +474,7 @@ namespace nodetool
 
       if (!full_addrs.size())
       {
-        LOG_PRINT_L0("DNS seed node lookup either timed out or failed, falling back to defaults");
+        MINFO("DNS seed node lookup either timed out or failed, falling back to defaults");
         full_addrs.insert("198.74.231.92:18080");
         full_addrs.insert("161.67.132.39:18080");
         full_addrs.insert("163.172.182.165:18080");
@@ -483,10 +485,10 @@ namespace nodetool
 
     for (const auto& full_addr : full_addrs)
     {
-      LOG_PRINT_L2("Seed node: " << full_addr);
+      MDEBUG("Seed node: " << full_addr);
       append_net_address(m_seed_nodes, full_addr);
     }
-    LOG_PRINT_L1("Number of seed nodes: " << m_seed_nodes.size());
+    MDEBUG("Number of seed nodes: " << m_seed_nodes.size());
 
     bool res = handle_command_line(vm, testnet);
     CHECK_AND_ASSERT_MES(res, false, "Failed to handle command line");
@@ -520,18 +522,18 @@ namespace nodetool
       return res;
 
     //try to bind
-    LOG_PRINT_L0("Binding on " << m_bind_ip << ":" << m_port);
+    MINFO("Binding on " << m_bind_ip << ":" << m_port);
     res = m_net_server.init_server(m_port, m_bind_ip);
     CHECK_AND_ASSERT_MES(res, false, "Failed to bind server");
 
     m_listenning_port = m_net_server.get_binded_port();
-    LOG_PRINT_GREEN("Net service bound to " << m_bind_ip << ":" << m_listenning_port, LOG_LEVEL_0);
+    MLOG_GREEN(el::Level::Info, "Net service bound to " << m_bind_ip << ":" << m_listenning_port);
     if(m_external_port)
-      LOG_PRINT_L0("External port defined as " << m_external_port);
+      MDEBUG("External port defined as " << m_external_port);
 
     // Add UPnP port mapping
     if(m_no_igd == false) {
-      LOG_PRINT_L0("Attempting to add IGD port mapping.");
+      MDEBUG("Attempting to add IGD port mapping.");
       int result;
 #if MINIUPNPC_API_VERSION > 13
       // default according to miniupnpc.h
@@ -558,19 +560,19 @@ namespace nodetool
           if (portMappingResult != 0) {
             LOG_ERROR("UPNP_AddPortMapping failed, error: " << strupnperror(portMappingResult));
           } else {
-            LOG_PRINT_GREEN("Added IGD port mapping.", LOG_LEVEL_0);
+            MLOG_GREEN(el::Level::Info, "Added IGD port mapping.");
           }
         } else if (result == 2) {
-          LOG_PRINT_L0("IGD was found but reported as not connected.");
+          MWARNING("IGD was found but reported as not connected.");
         } else if (result == 3) {
-          LOG_PRINT_L0("UPnP device was found but not recognized as IGD.");
+          MWARNING("UPnP device was found but not recognized as IGD.");
         } else {
-          LOG_ERROR("UPNP_GetValidIGD returned an unknown result code.");
+          MWARNING("UPNP_GetValidIGD returned an unknown result code.");
         }
 
         FreeUPNPUrls(&urls);
       } else {
-        LOG_PRINT_L0("No IGD was found.");
+        MINFO("No IGD was found.");
       }
     }
     return res;
@@ -600,9 +602,6 @@ namespace nodetool
         }); // lambda
 
         m_current_number_of_out_peers = number_of_peers;
-        if (epee::net_utils::data_logger::is_dying())
-          break;
-        epee::net_utils::data_logger::get_instance().add_data("peers", number_of_peers);
 
         boost::this_thread::sleep_for(boost::chrono::seconds(1));
       } // main loop of thread
@@ -619,13 +618,13 @@ namespace nodetool
     attrs.set_stack_size(THREAD_STACK_SIZE);
 
     //go to loop
-    LOG_PRINT("Run net_service loop( " << thrds_count << " threads)...", LOG_LEVEL_0);
+    MINFO("Run net_service loop( " << thrds_count << " threads)...");
     if(!m_net_server.run_server(thrds_count, true, attrs))
     {
       LOG_ERROR("Failed to run net tcp server!");
     }
 
-    LOG_PRINT("net_service loop stopped.", LOG_LEVEL_0);
+    MINFO("net_service loop stopped.");
     return true;
   }
 
@@ -652,7 +651,7 @@ namespace nodetool
     TRY_ENTRY();
     if (!tools::create_directories_if_necessary(m_config_folder))
     {
-      LOG_PRINT_L0("Failed to create data directory: " << m_config_folder);
+      MWARNING("Failed to create data directory: " << m_config_folder);
       return false;
     }
 
@@ -661,7 +660,7 @@ namespace nodetool
     p2p_data.open( state_file_path , std::ios_base::binary | std::ios_base::out| std::ios::trunc);
     if(p2p_data.fail())
     {
-      LOG_PRINT_L0("Failed to save config to file " << state_file_path);
+      MWARNING("Failed to save config to file " << state_file_path);
       return false;
     };
 
@@ -678,7 +677,7 @@ namespace nodetool
   {
     m_payload_handler.stop();
     m_net_server.send_stop_signal();
-    LOG_PRINT_L0("[node] Stop signal sent");
+    MDEBUG("[node] Stop signal sent");
     return true;
   }
   //-----------------------------------------------------------------------------------
@@ -702,19 +701,19 @@ namespace nodetool
 
       if(code < 0)
       {
-        LOG_PRINT_CC_RED(context, "COMMAND_HANDSHAKE invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")", LOG_LEVEL_1);
+        LOG_ERROR_CC(context, "COMMAND_HANDSHAKE invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")");
         return;
       }
 
       if(rsp.node_data.network_id != m_network_id)
       {
-        LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE Failed, wrong network!  (" << epee::string_tools::get_str_from_guid_a(rsp.node_data.network_id) << "), closing connection.");
+        LOG_ERROR_CC(context, "COMMAND_HANDSHAKE Failed, wrong network!  (" << epee::string_tools::get_str_from_guid_a(rsp.node_data.network_id) << "), closing connection.");
         return;
       }
 
       if(!handle_remote_peerlist(rsp.local_peerlist, rsp.node_data.local_time, context))
       {
-        LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE: failed to handle_remote_peerlist(...), closing connection.");
+        LOG_ERROR_CC(context, "COMMAND_HANDSHAKE: failed to handle_remote_peerlist(...), closing connection.");
         add_ip_fail(context.m_remote_ip);
         return;
       }
@@ -723,7 +722,7 @@ namespace nodetool
       {
         if(!m_payload_handler.process_payload_sync_data(rsp.payload_data, context, true))
         {
-          LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE invoked, but process_payload_sync_data returned false, dropping connection.");
+          LOG_ERROR_CC(context, "COMMAND_HANDSHAKE invoked, but process_payload_sync_data returned false, dropping connection.");
           hsh_result = false;
           return;
         }
@@ -733,14 +732,14 @@ namespace nodetool
 
         if(rsp.node_data.peer_id == m_config.m_peer_id)
         {
-          LOG_PRINT_CCONTEXT_L2("Connection to self detected, dropping connection");
+          LOG_DEBUG_CC(context, "Connection to self detected, dropping connection");
           hsh_result = false;
           return;
         }
-        LOG_PRINT_CCONTEXT_L1(" COMMAND_HANDSHAKE INVOKED OK");
+        LOG_DEBUG_CC(context, " COMMAND_HANDSHAKE INVOKED OK");
       }else
       {
-        LOG_PRINT_CCONTEXT_L1(" COMMAND_HANDSHAKE(AND CLOSE) INVOKED OK");
+        LOG_DEBUG_CC(context, " COMMAND_HANDSHAKE(AND CLOSE) INVOKED OK");
       }
     }, P2P_DEFAULT_HANDSHAKE_INVOKE_TIMEOUT);
 
@@ -751,7 +750,7 @@ namespace nodetool
 
     if(!hsh_result)
     {
-      LOG_PRINT_CC_L1(context_, "COMMAND_HANDSHAKE Failed");
+      LOG_ERROR_CC(context_, "COMMAND_HANDSHAKE Failed");
       m_net_server.get_config_object().close(context_.m_connection_id);
     }
     else
@@ -776,13 +775,13 @@ namespace nodetool
     {
       if(code < 0)
       {
-        LOG_PRINT_CC_RED(context, "COMMAND_TIMED_SYNC invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")", LOG_LEVEL_1);
+        LOG_ERROR_CC(context, "COMMAND_TIMED_SYNC invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")");
         return;
       }
 
       if(!handle_remote_peerlist(rsp.local_peerlist, rsp.local_time, context))
       {
-        LOG_ERROR_CCONTEXT("COMMAND_TIMED_SYNC: failed to handle_remote_peerlist(...), closing connection.");
+        LOG_WARNING_CC(context, "COMMAND_TIMED_SYNC: failed to handle_remote_peerlist(...), closing connection.");
         m_net_server.get_config_object().close(context.m_connection_id );
         add_ip_fail(context.m_remote_ip);
       }
@@ -793,7 +792,7 @@ namespace nodetool
 
     if(!r)
     {
-      LOG_PRINT_CC_L2(context_, "COMMAND_TIMED_SYNC Failed");
+      LOG_ERROR_CC(context_, "COMMAND_TIMED_SYNC Failed");
       return false;
     }
     return true;
@@ -808,7 +807,7 @@ namespace nodetool
 
     size_t x = crypto::rand<size_t>()%(max_index+1);
     size_t res = (x*x*x)/(max_index*max_index); //parabola \/
-    LOG_PRINT_L3("Random connection index=" << res << "(x="<< x << ", max_index=" << max_index << ")");
+    MDEBUG("Random connection index=" << res << "(x="<< x << ", max_index=" << max_index << ")");
     return res;
   }
   //-----------------------------------------------------------------------------------
@@ -853,9 +852,9 @@ namespace nodetool
 #define LOG_PRINT_CC_PRIORITY_NODE(priority, con, msg) \
   do { \
     if (priority) {\
-      LOG_PRINT_CC_L1(con, msg); \
+      LOG_INFO_CC(con, "[priority]" << msg); \
     } else {\
-      LOG_PRINT_CC_L1(con, msg); \
+      LOG_INFO_CC(con, msg); \
     } \
   } while(0)
 
@@ -872,7 +871,7 @@ namespace nodetool
       m_current_number_of_out_peers --; // atomic variable, update time = 1s
       return false;
     }
-    LOG_PRINT_L1("Connecting to " << epee::string_tools::get_ip_string_from_int32(na.ip)  << ":"
+    MDEBUG("Connecting to " << epee::string_tools::get_ip_string_from_int32(na.ip)  << ":"
         << epee::string_tools::num_to_string_fast(na.port) << "(white=" << white << ", last_seen: "
         << (last_seen_stamp ? epee::misc_utils::get_time_interval_string(time(NULL) - last_seen_stamp):"never")
         << ")...");
@@ -910,7 +909,7 @@ namespace nodetool
     if(just_take_peerlist)
     {
       m_net_server.get_config_object().close(con.m_connection_id);
-      LOG_PRINT_CC_GREEN(con, "CONNECTION HANDSHAKED OK AND CLOSED.", LOG_LEVEL_2);
+      LOG_DEBUG_CC(con, "CONNECTION HANDSHAKED OK AND CLOSED.");
       return true;
     }
 
@@ -923,7 +922,7 @@ namespace nodetool
     m_peerlist.append_with_peer_white(pe_local);
     //update last seen and push it to peerlist manager
 
-    LOG_PRINT_CC_GREEN(con, "CONNECTION HANDSHAKED OK.", LOG_LEVEL_2);
+    LOG_DEBUG_CC(con, "CONNECTION HANDSHAKED OK.");
     return true;
   }
 
@@ -986,7 +985,7 @@ namespace nodetool
       if(is_addr_recently_failed(pe.adr))
         continue;
 
-      LOG_PRINT_L2("Selected peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip)
+      MDEBUG("Selected peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip)
                     << ":" << boost::lexical_cast<std::string>(pe.adr.port)
                     << "[white=" << use_white_list
                     << "] last_seen: " << (pe.last_seen ? epee::misc_utils::get_time_interval_string(time(NULL) - pe.last_seen) : "never"));
@@ -1021,7 +1020,7 @@ namespace nodetool
           break;
         if(++try_count > m_seed_nodes.size())
         {
-          LOG_PRINT_RED_L0("Failed to connect to any of seed peers, continuing without seeds");
+          MWARNING("Failed to connect to any of seed peers, continuing without seeds");
           break;
         }
         if(++current_index >= m_seed_nodes.size())
@@ -1105,7 +1104,7 @@ namespace nodetool
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::peer_sync_idle_maker()
   {
-    LOG_PRINT_L2("STARTED PEERLIST IDLE HANDSHAKE");
+    MDEBUG("STARTED PEERLIST IDLE HANDSHAKE");
     typedef std::list<std::pair<epee::net_utils::connection_context_base, peerid_type> > local_connects_type;
     local_connects_type cncts;
     m_net_server.get_config_object().foreach_connection([&](const p2p_connection_context& cntxt)
@@ -1117,7 +1116,7 @@ namespace nodetool
 
     std::for_each(cncts.begin(), cncts.end(), [&](const typename local_connects_type::value_type& vl){do_peer_timed_sync(vl.first, vl.second);});
 
-    LOG_PRINT_L2("FINISHED PEERLIST IDLE HANDSHAKE");
+    MDEBUG("FINISHED PEERLIST IDLE HANDSHAKE");
     return true;
   }
   //-----------------------------------------------------------------------------------
@@ -1133,7 +1132,7 @@ namespace nodetool
     {
       if(be.last_seen > local_time)
       {
-        LOG_PRINT_RED_L1("FOUND FUTURE peerlist for entry " << epee::string_tools::get_ip_string_from_int32(be.adr.ip) << ":" << be.adr.port << " last_seen: " << be.last_seen << ", local_time(on remote node):" << local_time);
+        MWARNING("FOUND FUTURE peerlist for entry " << epee::string_tools::get_ip_string_from_int32(be.adr.ip) << ":" << be.adr.port << " last_seen: " << be.last_seen << ", local_time(on remote node):" << local_time);
         return false;
       }
       be.last_seen += delta;
@@ -1148,8 +1147,8 @@ namespace nodetool
     std::list<peerlist_entry> peerlist_ = peerlist;
     if(!fix_time_delta(peerlist_, local_time, delta))
       return false;
-    LOG_PRINT_CCONTEXT_L2("REMOTE PEERLIST: TIME_DELTA: " << delta << ", remote peerlist size=" << peerlist_.size());
+    LOG_DEBUG_CC(context, "REMOTE PEERLIST: TIME_DELTA: " << delta << ", remote peerlist size=" << peerlist_.size());
-    LOG_PRINT_CCONTEXT_L3("REMOTE PEERLIST: " <<  print_peerlist_to_string(peerlist_));
+    LOG_DEBUG_CC(context, "REMOTE PEERLIST: " <<  print_peerlist_to_string(peerlist_));
     return m_peerlist.merge_peerlist(peerlist_);
   }
   //-----------------------------------------------------------------------------------
@@ -1332,7 +1331,7 @@ namespace nodetool
     {
       if(ec)
       {
-        LOG_PRINT_CC_L2(ping_context, "back ping connect failed to " << ip << ":" << port);
+        LOG_WARNING_CC(ping_context, "back ping connect failed to " << ip << ":" << port);
         return false;
       }
       COMMAND_PING::request req;
@@ -1351,13 +1350,13 @@ namespace nodetool
       {
         if(code <= 0)
         {
-          LOG_PRINT_CC_L2(ping_context, "Failed to invoke COMMAND_PING to " << ip << ":" << port << "(" << code <<  ", " << epee::levin::get_err_descr(code) << ")");
+          LOG_ERROR_CC(ping_context, "Failed to invoke COMMAND_PING to " << ip << ":" << port << "(" << code <<  ", " << epee::levin::get_err_descr(code) << ")");
           return;
         }
 
         if(rsp.status != PING_OK_RESPONSE_STATUS_TEXT || pr != rsp.peer_id)
         {
-          LOG_PRINT_CC_L2(ping_context, "back ping invoke wrong response \"" << rsp.status << "\" from" << ip << ":" << port << ", hsh_peer_id=" << pr_ << ", rsp.peer_id=" << rsp.peer_id);
+          LOG_ERROR_CC(ping_context, "back ping invoke wrong response \"" << rsp.status << "\" from" << ip << ":" << port << ", hsh_peer_id=" << pr_ << ", rsp.peer_id=" << rsp.peer_id);
           m_net_server.get_config_object().close(ping_context.m_connection_id);
           return;
         }
@@ -1367,7 +1366,7 @@ namespace nodetool
 
       if(!inv_call_res)
       {
-        LOG_PRINT_CC_L2(ping_context, "back ping invoke failed to " << ip << ":" << port);
+        LOG_ERROR_CC(ping_context, "back ping invoke failed to " << ip << ":" << port);
         m_net_server.get_config_object().close(ping_context.m_connection_id);
         return false;
       }
@@ -1375,7 +1374,7 @@ namespace nodetool
     });
     if(!r)
     {
-      LOG_ERROR("Failed to call connect_async, network error.");
+      LOG_ERROR_CC(context, "Failed to call connect_async, network error.");
     }
     return r;
   }
@@ -1394,7 +1393,7 @@ namespace nodetool
       {  
         if(code < 0)
         {
-          LOG_PRINT_CC_RED(context_, "COMMAND_REQUEST_SUPPORT_FLAGS invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")", LOG_LEVEL_1);
+          LOG_ERROR_CC(context_, "COMMAND_REQUEST_SUPPORT_FLAGS invoke failed. (" << code <<  ", " << epee::levin::get_err_descr(code) << ")");
           return;
         }
         
@@ -1411,7 +1410,7 @@ namespace nodetool
   {
     if(!m_payload_handler.process_payload_sync_data(arg.payload_data, context, false))
     {
-      LOG_ERROR_CCONTEXT("Failed to process_payload_sync_data(), dropping connection");
+      LOG_ERROR_CC(context, "Failed to process_payload_sync_data(), dropping connection");
       drop_connection(context);
       return 1;
     }
@@ -1420,7 +1419,7 @@ namespace nodetool
     rsp.local_time = time(NULL);
     m_peerlist.get_peerlist_head(rsp.local_peerlist);
     m_payload_handler.get_payload_sync_data(rsp.payload_data);
-    LOG_PRINT_CCONTEXT_L2("COMMAND_TIMED_SYNC");
+    LOG_DEBUG_CC(context, "COMMAND_TIMED_SYNC");
     return 1;
   }
   //-----------------------------------------------------------------------------------
@@ -1430,7 +1429,7 @@ namespace nodetool
     if(arg.node_data.network_id != m_network_id)
     {
 
-      LOG_PRINT_CCONTEXT_L1("WRONG NETWORK AGENT CONNECTED! id=" << epee::string_tools::get_str_from_guid_a(arg.node_data.network_id));
+      LOG_INFO_CC(context, "WRONG NETWORK AGENT CONNECTED! id=" << epee::string_tools::get_str_from_guid_a(arg.node_data.network_id));
       drop_connection(context);
       add_ip_fail(context.m_remote_ip);
       return 1;
@@ -1438,7 +1437,7 @@ namespace nodetool
 
     if(!context.m_is_income)
     {
-      LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE came not from incoming connection");
+      LOG_ERROR_CC(context, "COMMAND_HANDSHAKE came not from incoming connection");
       drop_connection(context);
       add_ip_fail(context.m_remote_ip);
       return 1;
@@ -1446,14 +1445,14 @@ namespace nodetool
 
     if(context.peer_id)
     {
-      LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE came, but seems that connection already have associated peer_id (double COMMAND_HANDSHAKE?)");
+      LOG_ERROR_CC(context, "COMMAND_HANDSHAKE came, but seems that connection already have associated peer_id (double COMMAND_HANDSHAKE?)");
       drop_connection(context);
       return 1;
     }
 
     if(!m_payload_handler.process_payload_sync_data(arg.payload_data, context, true))
     {
-      LOG_ERROR_CCONTEXT("COMMAND_HANDSHAKE came, but process_payload_sync_data returned false, dropping connection.");
+      LOG_ERROR_CC(context, "COMMAND_HANDSHAKE came, but process_payload_sync_data returned false, dropping connection.");
       drop_connection(context);
       return 1;
     }
@@ -1476,7 +1475,7 @@ namespace nodetool
         pe.last_seen = static_cast<int64_t>(last_seen);
         pe.id = peer_id_l;
         this->m_peerlist.append_with_peer_white(pe);
-        LOG_PRINT_CCONTEXT_L2("PING SUCCESS " << epee::string_tools::get_ip_string_from_int32(context.m_remote_ip) << ":" << port_l);
+        LOG_DEBUG_CC(context, "PING SUCCESS " << epee::string_tools::get_ip_string_from_int32(context.m_remote_ip) << ":" << port_l);
       });
     }
     
@@ -1489,14 +1488,14 @@ namespace nodetool
     m_peerlist.get_peerlist_head(rsp.local_peerlist);
     get_local_node_data(rsp.node_data);
     m_payload_handler.get_payload_sync_data(rsp.payload_data);
-    LOG_PRINT_CCONTEXT_GREEN("COMMAND_HANDSHAKE", LOG_LEVEL_1);
+    LOG_DEBUG_CC(context, "COMMAND_HANDSHAKE");
     return 1;
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
   int node_server<t_payload_net_handler>::handle_ping(int command, COMMAND_PING::request& arg, COMMAND_PING::response& rsp, p2p_connection_context& context)
   {
-    LOG_PRINT_CCONTEXT_L2("COMMAND_PING");
+    LOG_DEBUG_CC(context, "COMMAND_PING");
     rsp.status = PING_OK_RESPONSE_STATUS_TEXT;
     rsp.peer_id = m_config.m_peer_id;
     return 1;
@@ -1508,14 +1507,14 @@ namespace nodetool
     std::list<peerlist_entry> pl_white;
     std::list<peerlist_entry> pl_gray;
     m_peerlist.get_peerlist_full(pl_gray, pl_white);
-    LOG_PRINT_L0(ENDL << "Peerlist white:" << ENDL << print_peerlist_to_string(pl_white) << ENDL << "Peerlist gray:" << ENDL << print_peerlist_to_string(pl_gray) );
+    MINFO(ENDL << "Peerlist white:" << ENDL << print_peerlist_to_string(pl_white) << ENDL << "Peerlist gray:" << ENDL << print_peerlist_to_string(pl_gray) );
     return true;
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::log_connections()
   {
-    LOG_PRINT_L0("Connections: \r\n" << print_connections_container() );
+    MINFO("Connections: \r\n" << print_connections_container() );
     return true;
   }
   //-----------------------------------------------------------------------------------
@@ -1539,13 +1538,13 @@ namespace nodetool
   template<class t_payload_net_handler>
   void node_server<t_payload_net_handler>::on_connection_new(p2p_connection_context& context)
   {
-    LOG_PRINT_L2("["<< epee::net_utils::print_connection_context(context) << "] NEW CONNECTION");
+    MINFO("["<< epee::net_utils::print_connection_context(context) << "] NEW CONNECTION");
   }
   //-----------------------------------------------------------------------------------
   template<class t_payload_net_handler>
   void node_server<t_payload_net_handler>::on_connection_close(p2p_connection_context& context)
   {
-    LOG_PRINT_L2("["<< epee::net_utils::print_connection_context(context) << "] CLOSE CONNECTION");
+    MINFO("["<< epee::net_utils::print_connection_context(context) << "] CLOSE CONNECTION");
   }
 
   template<class t_payload_net_handler>
@@ -1595,10 +1594,8 @@ namespace nodetool
   {
     if(max == -1) {
       m_config.m_net_config.connections_count = P2P_DEFAULT_CONNECTIONS_COUNT;
-      epee::net_utils::data_logger::get_instance().add_data("peers_limit", m_config.m_net_config.connections_count);
       return true;
     }
-    epee::net_utils::data_logger::get_instance().add_data("peers_limit", max);
     m_config.m_net_config.connections_count = max;
     return true;
   }
@@ -1632,7 +1629,7 @@ namespace nodetool
 
     limit *= 1024;
     epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_up_limit( limit );
-    LOG_PRINT_L0("Set limit-up to " << limit/1024 << " kB/s");
+    MINFO("Set limit-up to " << limit/1024 << " kB/s");
     return true;
   }
 
@@ -1646,7 +1643,7 @@ namespace nodetool
     }
     limit *= 1024;
     epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_down_limit( limit );
-    LOG_PRINT_L0("Set limit-down to " << limit/1024 << " kB/s");
+    MINFO("Set limit-down to " << limit/1024 << " kB/s");
     return true;
   }
 
@@ -1668,11 +1665,11 @@ namespace nodetool
     }
     if(!this->islimitup) {
       epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_up_limit(limit_up);
-      LOG_PRINT_L0("Set limit-up to " << limit_up/1024 << " kB/s");
+      MINFO("Set limit-up to " << limit_up/1024 << " kB/s");
     }
     if(!this->islimitdown) {
       epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_down_limit(limit_down);
-      LOG_PRINT_L0("Set limit-down to " << limit_down/1024 << " kB/s");
+      MINFO("Set limit-down to " << limit_down/1024 << " kB/s");
     }
 
     return true;

src/p2p/network_throttle-detail.cpp

@@ -77,9 +77,8 @@
 // TODO:
 #include "../../src/p2p/network_throttle-detail.hpp"
 
-#include "../../contrib/otshell_utils/utils.hpp"
+#undef MONERO_DEFAULT_LOG_CATEGORY
-#include "data_logger.hpp"
+#define MONERO_DEFAULT_LOG_CATEGORY "net.throttle"
-using namespace nOT::nUtils;
 
 // ################################################################################################
 // ################################################################################################
@@ -89,8 +88,6 @@ using namespace nOT::nUtils;
 // ################################################################################################
 // ################################################################################################
 
-using namespace nOT::nUtils;
-
 namespace epee
 {
 namespace net_utils
@@ -163,7 +160,7 @@ void network_throttle::set_name(const std::string &name)
 void network_throttle::set_target_speed( network_speed_kbps target ) 
 {
     m_target_speed = target * 1024;
-	_note_c("net/"+m_nameshort, "Setting LIMIT: " << target << " kbps");
+	MINFO("Setting LIMIT: " << target << " kbps");
 	set_real_target_speed(target);
 }
 
@@ -220,7 +217,7 @@ void network_throttle::_handle_trafic_exact(size_t packet_size, size_t orginal_s
 	std::ostringstream oss; oss << "["; 	for (auto sample: m_history) oss << sample.m_size << " ";	 oss << "]" << std::ends;
 	std::string history_str = oss.str();
 
-	_dbg2_c( "net/" + m_nameshort , "Throttle " << m_name << ": packet of ~"<<packet_size<<"b " << " (from "<<orginal_size<<" b)" 
+	MDEBUG("Throttle " << m_name << ": packet of ~"<<packet_size<<"b " << " (from "<<orginal_size<<" b)"
         << " Speed AVG=" << std::setw(4) <<  ((long int)(cts .average/1024)) <<"[w="<<cts .window<<"]"
         <<           " " << std::setw(4) <<  ((long int)(cts2.average/1024)) <<"[w="<<cts2.window<<"]"
 				<<" / " << " Limit="<< ((long int)(m_target_speed/1024)) <<" KiB/sec "
@@ -241,8 +238,6 @@ network_time_seconds network_throttle::get_sleep_time_after_tick(size_t packet_s
 }
 
 void network_throttle::logger_handle_net(const std::string &filename, double time, size_t size) {
-	if (! epee::net_utils::data_logger::m_save_graph)
-		return;
     boost::mutex mutex;
     mutex.lock(); {
         std::fstream file;
@@ -312,8 +307,7 @@ void network_throttle::calculate_times(size_t packet_size, calculate_times_struc
 	if (dbg) {
 		std::ostringstream oss; oss << "["; 	for (auto sample: m_history) oss << sample.m_size << " ";	 oss << "]" << std::ends;
 		std::string history_str = oss.str();
-		_dbg1_c( "net/"+m_nameshort+"_c" ,
+		MDEBUG((cts.delay > 0 ? "SLEEP" : "")
-			(cts.delay > 0 ? "SLEEP" : "")
 			<< "dbg " << m_name << ": " 
 			<< "speed is A=" << std::setw(8) <<cts.average<<" vs "
 			<< "Max=" << std::setw(8) <<M<<" "

src/ringct/rctOps.cpp

@@ -33,6 +33,9 @@
 using namespace crypto;
 using namespace std;
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "ringct"
+
 namespace rct {
 
     //Various key initialization functions

src/ringct/rctSigs.cpp

@@ -39,6 +39,9 @@
 using namespace crypto;
 using namespace std;
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "ringct"
+
 namespace rct {
     //Borromean (c.f. gmax/andytoshi's paper)
     boroSig genBorromean(const key64 x, const key64 P1, const key64 P2, const bits indices) {

src/ringct/rctTypes.cpp

@@ -32,6 +32,9 @@
 using namespace crypto;
 using namespace std;
 
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "ringct"
+
 namespace rct {
 
     //dp 

src/rpc/core_rpc_server.cpp

@@ -678,17 +678,20 @@ namespace cryptonote
   //------------------------------------------------------------------------------------------------------------------------------
   bool core_rpc_server::on_set_log_level(const COMMAND_RPC_SET_LOG_LEVEL::request& req, COMMAND_RPC_SET_LOG_LEVEL::response& res)
   {
-    if (req.level < LOG_LEVEL_MIN || req.level > LOG_LEVEL_MAX)
+    if (req.level < 0 || req.level > 4)
     {
       res.status = "Error: log level not valid";
+      return true;
     }
-    else
+    mlog_set_log_level(req.level);
-    {
-      epee::log_space::log_singletone::get_set_log_detalisation_level(true, req.level);
-      int otshell_utils_log_level = 100 - (req.level * 20);
-      gCurrentLogger.setDebugLevel(otshell_utils_log_level);
     res.status = CORE_RPC_STATUS_OK;
+    return true;
   }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool core_rpc_server::on_set_log_categories(const COMMAND_RPC_SET_LOG_CATEGORIES::request& req, COMMAND_RPC_SET_LOG_CATEGORIES::response& res)
+  {
+    mlog_set_categories(req.categories.c_str());
+    res.status = CORE_RPC_STATUS_OK;
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------------