Merge pull request #4852 from pwojcikdev/log-ledger-path

Log ledger data path on startup

nano/core_test/block_store.cpp

@@ -633,7 +633,7 @@ TEST (mdb_block_store, supported_version_upgrades)
 	{
 		nano::store::lmdb::component store (logger, path, nano::dev::constants);
 		nano::stats stats{ logger };
-		nano::ledger ledger (store, stats, nano::dev::constants);
+		nano::ledger ledger (store, nano::dev::constants, stats, logger);
 		auto transaction (store.tx_begin_write ());
 		store.initialize (transaction, ledger.cache, nano::dev::constants);
 		// Lower the database to the max version unsupported for upgrades
@@ -651,7 +651,7 @@ TEST (mdb_block_store, supported_version_upgrades)
 	{
 		nano::store::lmdb::component store (logger, path1, nano::dev::constants);
 		nano::stats stats{ logger };
-		nano::ledger ledger (store, stats, nano::dev::constants);
+		nano::ledger ledger (store, nano::dev::constants, stats, logger);
 		auto transaction (store.tx_begin_write ());
 		store.initialize (transaction, ledger.cache, nano::dev::constants);
 		// Lower the database version to the minimum version supported for upgrade.
@@ -899,7 +899,7 @@ TEST (block_store, cemented_count_cache)
 	ASSERT_TRUE (!store->init_error ());
 	auto transaction (store->tx_begin_write ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	store->initialize (transaction, ledger.cache, nano::dev::constants);
 	ASSERT_EQ (1, ledger.cemented_count ());
 }
@@ -987,7 +987,7 @@ TEST (mdb_block_store, sideband_height)
 	nano::store::lmdb::component store (logger, nano::unique_path () / "data.ldb", nano::dev::constants);
 	ASSERT_FALSE (store.init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (store, stats, nano::dev::constants);
+	nano::ledger ledger (store, nano::dev::constants, stats, logger);
 	nano::block_builder builder;
 	auto transaction = ledger.tx_begin_write ();
 	store.initialize (transaction, ledger.cache, nano::dev::constants);

nano/core_test/ledger.cpp

@@ -871,7 +871,7 @@ TEST (ledger, double_open)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
 	nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
@@ -4736,7 +4736,7 @@ TEST (ledger, dependents_confirmed_pruning)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_FALSE (store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -4811,6 +4811,7 @@ TEST (ledger, cache)
 	auto & ledger = ctx.ledger ();
 	auto & store = ctx.store ();
 	auto & stats = ctx.stats ();
+	auto & logger = ctx.logger ();
 	auto & pool = ctx.pool ();
 	nano::block_builder builder;
 
@@ -4861,7 +4862,7 @@ TEST (ledger, cache)
 		++block_count;
 		--genesis_weight;
 		cache_check (ledger);
-		cache_check (nano::ledger (store, stats, nano::dev::constants));
+		cache_check (nano::ledger (store, nano::dev::constants, stats, logger));
 
 		{
 			auto transaction = ledger.tx_begin_write ();
@@ -4871,7 +4872,7 @@ TEST (ledger, cache)
 		++block_count;
 		++account_count;
 		cache_check (ledger);
-		cache_check (nano::ledger (store, stats, nano::dev::constants));
+		cache_check (nano::ledger (store, nano::dev::constants, stats, logger));
 
 		{
 			auto transaction = ledger.tx_begin_write ();
@@ -4881,7 +4882,7 @@ TEST (ledger, cache)
 
 		++cemented_count;
 		cache_check (ledger);
-		cache_check (nano::ledger (store, stats, nano::dev::constants));
+		cache_check (nano::ledger (store, nano::dev::constants, stats, logger));
 
 		{
 			auto transaction = ledger.tx_begin_write ();
@@ -4891,15 +4892,15 @@ TEST (ledger, cache)
 
 		++cemented_count;
 		cache_check (ledger);
-		cache_check (nano::ledger (store, stats, nano::dev::constants));
+		cache_check (nano::ledger (store, nano::dev::constants, stats, logger));
 
 		{
 			auto transaction = ledger.tx_begin_write ();
 			ledger.pruning_action (transaction, open->hash (), 1);
 		}
 		++pruned_count;
 		cache_check (ledger);
-		cache_check (nano::ledger (store, stats, nano::dev::constants));
+		cache_check (nano::ledger (store, nano::dev::constants, stats, logger));
 	}
 }
 
@@ -4909,7 +4910,7 @@ TEST (ledger, pruning_action)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -4995,7 +4996,7 @@ TEST (ledger, pruning_large_chain)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -5051,7 +5052,7 @@ TEST (ledger, pruning_source_rollback)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -5140,7 +5141,7 @@ TEST (ledger, pruning_source_rollback_legacy)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -5254,7 +5255,7 @@ TEST (ledger, pruning_legacy_blocks)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	nano::keypair key1;
 	auto transaction = ledger.tx_begin_write ();
@@ -5341,7 +5342,7 @@ TEST (ledger, pruning_safe_functions)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -5393,7 +5394,7 @@ TEST (ledger, random_blocks)
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
 	nano::stats stats{ logger };
-	nano::ledger ledger (*store, stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
@@ -5481,7 +5482,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
 	boost::asio::ip::address_v6 address (boost::asio::ip::make_address_v6 ("::ffff:127.0.0.1"));
 	uint16_t port = 100;
 	nano::store::lmdb::component store{ logger, path / "data.ldb", nano::dev::constants };
-	nano::ledger ledger{ store, system.stats, nano::dev::constants };
+	nano::ledger ledger{ store, nano::dev::constants, system.stats, system.logger };
 	nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
 
 	std::shared_ptr<nano::block> send = nano::state_block_builder ()

nano/core_test/ledger_confirm.cpp

@@ -760,7 +760,7 @@ TEST (ledger_confirm, pruned_source)
 	auto path (nano::unique_path ());
 	auto store = nano::make_store (system.logger, path, nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
-	nano::ledger ledger (*store, system.stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, system.stats, system.logger);
 	ledger.pruning = true;
 	nano::store::write_queue write_queue;
 	nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
@@ -845,7 +845,7 @@ TEST (ledger_confirmDeathTest, rollback_added_block)
 		auto path (nano::unique_path ());
 		auto store = nano::make_store (system.logger, path, nano::dev::constants);
 		ASSERT_TRUE (!store->init_error ());
-		nano::ledger ledger (*store, system.stats, nano::dev::constants);
+		nano::ledger ledger (*store, nano::dev::constants, system.stats, system.logger);
 		nano::store::write_queue write_queue;
 		nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
 		nano::keypair key1;

nano/core_test/processor_service.cpp

@@ -18,7 +18,7 @@ TEST (processor_service, bad_send_signature)
 
 	auto store = nano::make_store (system.logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_FALSE (store->init_error ());
-	nano::ledger ledger (*store, system.stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, system.stats, system.logger);
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
 	nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
@@ -44,7 +44,7 @@ TEST (processor_service, bad_receive_signature)
 
 	auto store = nano::make_store (system.logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_FALSE (store->init_error ());
-	nano::ledger ledger (*store, system.stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, system.stats, system.logger);
 	auto transaction = ledger.tx_begin_write ();
 	store->initialize (transaction, ledger.cache, ledger.constants);
 	nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };

nano/lib/fwd.hpp

@@ -12,10 +12,12 @@ class block_details;
 class block_visitor;
 class container_info;
 class jsonconfig;
+class logger;
 class mutable_block_visitor;
 class network_constants;
 class object_stream;
 class root;
+class stats;
 class thread_pool;
 class thread_runner;
 class tomlconfig;

nano/nano_node/daemon.cpp

@@ -103,7 +103,7 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag
 		logger.info (nano::log::type::daemon, "Starting up Nano node...");
 
 		// Print info about number of logical cores detected, those are used to decide how many IO, worker and signature checker threads to spawn
-		logger.info (nano::log::type::daemon, "Hardware concurrency: {} ( configured: {} )", std::thread::hardware_concurrency (), nano::hardware_concurrency ());
+		logger.info (nano::log::type::daemon, "Hardware concurrency: {} (configured: {})", std::thread::hardware_concurrency (), nano::hardware_concurrency ());
 		logger.info (nano::log::type::daemon, "File descriptors limit: {}", nano::get_file_descriptor_limit ());
 
 		// for the daemon start up, if the user hasn't specified a port in

nano/node/node.cpp

@@ -117,7 +117,7 @@ nano::node::node (std::shared_ptr<boost::asio::io_context> io_ctx_a, std::filesy
 	wallets_store{ *wallets_store_impl },
 	wallets_impl{ std::make_unique<nano::wallets> (wallets_store.init_error (), *this) },
 	wallets{ *wallets_impl },
-	ledger_impl{ std::make_unique<nano::ledger> (store, stats, network_params.ledger, flags_a.generate_cache, config_a.representative_vote_weight_minimum.number ()) },
+	ledger_impl{ std::make_unique<nano::ledger> (store, network_params.ledger, stats, logger, flags_a.generate_cache, config_a.representative_vote_weight_minimum.number ()) },
 	ledger{ *ledger_impl },
 	ledger_notifications_impl{ std::make_unique<nano::ledger_notifications> (config, stats, logger) },
 	ledger_notifications{ *ledger_notifications_impl },
@@ -295,6 +295,7 @@ nano::node::node (std::shared_ptr<boost::asio::io_context> io_ctx_a, std::filesy
 		logger.info (nano::log::type::node, "Active network: {}", network_label);
 		logger.info (nano::log::type::node, "Database backend: {}", store.vendor_get ());
 		logger.info (nano::log::type::node, "Data path: {}", application_path.string ());
+		logger.info (nano::log::type::node, "Ledger path: {}", store.get_database_path ().string ());
 		logger.info (nano::log::type::node, "Work pool threads: {} ({})", work.threads.size (), (work.opencl ? "OpenCL" : "CPU"));
 		logger.info (nano::log::type::node, "Work peers: {}", config.work_peers.size ());
 		logger.info (nano::log::type::node, "Node ID: {}", node_id.pub.to_node_id ());
@@ -357,8 +358,8 @@ nano::node::node (std::shared_ptr<boost::asio::io_context> io_ctx_a, std::filesy
 			ledger.bootstrap_weight_max_blocks = bootstrap_weights.first;
 			ledger.bootstrap_weights = bootstrap_weights.second;
 
-			logger.info (nano::log::type::node, "Initial bootstrap height: {}", ledger.bootstrap_weight_max_blocks);
-			logger.info (nano::log::type::node, "Current ledger height:    {}", ledger.block_count ());
+			logger.info (nano::log::type::node, "Initial bootstrap height: {:>10}", ledger.bootstrap_weight_max_blocks);
+			logger.info (nano::log::type::node, "Current ledger height:    {:>10}", ledger.block_count ());
 
 			// Use bootstrap weights if initial bootstrap is not completed
 			const bool use_bootstrap_weight = !ledger.bootstrap_height_reached ();
@@ -409,6 +410,11 @@ nano::node::node (std::shared_ptr<boost::asio::io_context> io_ctx_a, std::filesy
 			}
 		});
 	}
+	else
+	{
+		logger.error (nano::log::type::node, "Failed to initialize node");
+	}
+
 	node_initialized_latch.count_down ();
 }
 
@@ -987,29 +993,36 @@ nano::container_info nano::node::container_info () const
 
 nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path)
 {
+	auto & logger = nano::default_logger ();
+
+	logger.info (nano::log::type::init, "Using data directory: {}", application_path.string ());
+
 	auto node_private_key_path = application_path / "node_id_private.key";
 	std::ifstream ifs (node_private_key_path.c_str ());
 	if (ifs.good ())
 	{
-		nano::default_logger ().info (nano::log::type::init, "Reading node id from: '{}'", node_private_key_path.string ());
-
 		std::string node_private_key;
 		ifs >> node_private_key;
 		release_assert (node_private_key.size () == 64);
 		nano::keypair kp = nano::keypair (node_private_key);
+
+		logger.info (nano::log::type::init, "Loaded local node ID: {}",
+		kp.pub.to_node_id ());
+
 		return kp;
 	}
 	else
 	{
-		// no node_id found, generate new one
-		nano::default_logger ().info (nano::log::type::init, "Generating a new node id, saving to: '{}'", node_private_key_path.string ());
-
 		nano::keypair kp;
 		std::ofstream ofs (node_private_key_path.c_str (), std::ofstream::out | std::ofstream::trunc);
 		ofs << kp.prv.to_string () << std::endl
 			<< std::flush;
 		ofs.close ();
 		release_assert (!ofs.fail ());
+
+		logger.info (nano::log::type::init, "Generated new local node ID: {}",
+		kp.pub.to_node_id ());
+
 		return kp;
 	}
-}
+}

nano/node/wallet.cpp

@@ -1245,7 +1245,7 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact
 	auto result (!store.valid_password (wallet_transaction_a));
 	if (!result)
 	{
-		logger.info (nano::log::type::wallet, "Beginning receivable block search");
+		logger.debug (nano::log::type::wallet, "Beginning receivable block search");
 
 		for (auto i (store.begin (wallet_transaction_a)), n (store.end (wallet_transaction_a)); i != n; ++i)
 		{
@@ -1284,11 +1284,11 @@ bool nano::wallet::search_receivable (store::transaction const & wallet_transact
 			}
 		}
 
-		logger.info (nano::log::type::wallet, "Receivable block search phase complete");
+		logger.debug (nano::log::type::wallet, "Receivable block search phase complete");
 	}
 	else
 	{
-		logger.warn (nano::log::type::wallet, "Unable to search receivable blocks, wallet is locked");
+		logger.warn (nano::log::type::wallet, "Unable to search receivable blocks, wallet is locked. Blocks won't be auto-received until the wallet is unlocked");
 	}
 	return result;
 }
@@ -1431,6 +1431,8 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) :
 	env (boost::polymorphic_downcast<nano::mdb_wallets_store *> (node_a.wallets_store_impl.get ())->environment),
 	stopped (false)
 {
+	logger.info (nano::log::type::wallet, "Loading wallets from: {}", env.database_path.string ());
+
 	nano::unique_lock<nano::mutex> lock{ mutex };
 	if (!error_a)
 	{
@@ -1462,6 +1464,9 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) :
 			}
 		}
 	}
+
+	logger.info (nano::log::type::wallet, "Found {} wallet(s)", items.size ());
+
 	// Backup before upgrade wallets
 	bool backup_required (false);
 	if (node.config.backup_before_upgrade)

nano/qt_test/qt.cpp

@@ -518,9 +518,10 @@ TEST (history, short_text)
 	}
 	auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
 	nano::logger logger;
+	nano::stats stats{ logger };
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
-	nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	{
 		auto transaction (ledger.tx_begin_write ());
 		store->initialize (transaction, ledger.cache, ledger.constants);
@@ -556,9 +557,10 @@ TEST (history, pruned_source)
 	}
 	auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
 	nano::logger logger;
+	nano::stats stats{ logger };
 	auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
 	ASSERT_TRUE (!store->init_error ());
-	nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants);
+	nano::ledger ledger (*store, nano::dev::constants, stats, logger);
 	ledger.pruning = true;
 	nano::block_hash next_pruning;
 	// Basic pruning for legacy blocks. Previous block is pruned, source is pruned