Rework collect_container_info (..) functions (#4736)

* Move container info classes to separate file

* Introduce better `container_info` class

* Rename legacy to `container_info_entry`

* Conversion

* Test

* Fixes

nano/core_test/node.cpp

@@ -3794,4 +3794,25 @@ TEST (node, local_block_broadcast)
 	node1.network.merge_peer (node2.network.endpoint ());
 	ASSERT_TIMELY (5s, node1.network.find_node_id (node2.get_node_id ()));
 	ASSERT_TIMELY (10s, node2.block (send1->hash ()));
+}
+
+TEST (node, container_info)
+{
+	nano::test::system system;
+	auto & node1 = *system.add_node ();
+	auto & node2 = *system.add_node ();
+
+	// Generate some random activity
+	std::vector<nano::account> accounts;
+	auto dev_genesis_key = nano::dev::genesis_key;
+	system.wallet (0)->insert_adhoc (dev_genesis_key.prv);
+	accounts.push_back (dev_genesis_key.pub);
+	for (int n = 0; n < 10; ++n)
+	{
+		system.generate_activity (node1, accounts);
+	}
+
+	// This should just execute, sanitizers will catch any problems
+	ASSERT_NO_THROW (node1.container_info ());
+	ASSERT_NO_THROW (node2.container_info ());
 }

nano/lib/CMakeLists.txt

@@ -36,6 +36,8 @@ add_library(
   config.hpp
   config.cpp
   configbase.hpp
+  container_info.hpp
+  container_info.cpp
   diagnosticsconfig.hpp
   diagnosticsconfig.cpp
   env.hpp

nano/lib/container_info.cpp

@@ -0,0 +1,41 @@
+#include <nano/lib/container_info.hpp>
+
+nano::container_info_composite::container_info_composite (std::string name) :
+	name (std::move (name))
+{
+}
+
+bool nano::container_info_composite::is_composite () const
+{
+	return true;
+}
+
+void nano::container_info_composite::add_component (std::unique_ptr<container_info_component> child)
+{
+	children.push_back (std::move (child));
+}
+
+std::vector<std::unique_ptr<nano::container_info_component>> const & nano::container_info_composite::get_children () const
+{
+	return children;
+}
+
+std::string const & nano::container_info_composite::get_name () const
+{
+	return name;
+}
+
+nano::container_info_leaf::container_info_leaf (container_info_entry info) :
+	info (std::move (info))
+{
+}
+
+bool nano::container_info_leaf::is_composite () const
+{
+	return false;
+}
+
+nano::container_info_entry const & nano::container_info_leaf::get_info () const
+{
+	return info;
+}

nano/lib/container_info.hpp

@@ -0,0 +1,172 @@
+#pragma once
+
+#include <list>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace nano
+{
+/* These containers are used to collect information about sequence containers.
+ * It makes use of the composite design pattern to collect information
+ * from sequence containers and sequence containers inside member variables.
+ */
+struct container_info_entry
+{
+	std::string name;
+	size_t count;
+	size_t sizeof_element;
+};
+
+class container_info_component
+{
+public:
+	virtual ~container_info_component () = default;
+	virtual bool is_composite () const = 0;
+};
+
+class container_info_composite : public container_info_component
+{
+public:
+	container_info_composite (std::string name);
+	bool is_composite () const override;
+	void add_component (std::unique_ptr<container_info_component> child);
+	std::vector<std::unique_ptr<container_info_component>> const & get_children () const;
+	std::string const & get_name () const;
+
+private:
+	std::string name;
+	std::vector<std::unique_ptr<container_info_component>> children;
+};
+
+class container_info_leaf : public container_info_component
+{
+public:
+	container_info_leaf (container_info_entry);
+	bool is_composite () const override;
+	container_info_entry const & get_info () const;
+
+private:
+	container_info_entry info;
+};
+}
+
+/*
+ * New version
+ */
+namespace nano
+{
+class container_info;
+
+template <typename T>
+concept sized_container = requires (T a) {
+	typename T::value_type;
+	{
+		a.size ()
+	} -> std::convertible_to<std::size_t>;
+};
+
+template <typename T>
+concept container_info_collectable = requires (T a) {
+	{
+		a.collect_info ()
+	} -> std::convertible_to<container_info>;
+};
+
+class container_info
+{
+public:
+	// Child represented as <name, container_info>
+	// Using pair to avoid problems with incomplete types
+	using child = std::pair<std::string, container_info>;
+
+	struct entry
+	{
+		std::string name;
+		std::size_t size;
+		std::size_t sizeof_element;
+	};
+
+public:
+	/**
+	 * Adds a subcontainer
+	 */
+	void add (std::string const & name, container_info const & info)
+	{
+		children_m.emplace_back (name, info);
+	}
+
+	template <container_info_collectable T>
+	void add (std::string const & name, T const & container)
+	{
+		add (name, container.collect_info ());
+	}
+
+	/**
+	 * Adds an entry to this container
+	 */
+	void put (std::string const & name, std::size_t size, std::size_t sizeof_element = 0)
+	{
+		entries_m.emplace_back (entry{ name, size, sizeof_element });
+	}
+
+	template <class T>
+	void put (std::string const & name, std::size_t size)
+	{
+		put (name, size, sizeof (T));
+	}
+
+	template <sized_container T>
+	void put (std::string const & name, T const & container)
+	{
+		put (name, container.size (), sizeof (typename T::value_type));
+	}
+
+public:
+	bool children_empty () const
+	{
+		return children_m.empty ();
+	}
+
+	auto const & children () const
+	{
+		return children_m;
+	}
+
+	bool entries_empty () const
+	{
+		return entries_m.empty ();
+	}
+
+	auto const & entries () const
+	{
+		return entries_m;
+	}
+
+public:
+	// Needed to convert to legacy container_info_component during transition period
+	std::unique_ptr<nano::container_info_component> to_legacy (std::string const & name) const
+	{
+		auto composite = std::make_unique<nano::container_info_composite> (name);
+
+		// Add entries as leaf components
+		for (const auto & entry : entries_m)
+		{
+			nano::container_info_entry info{ entry.name, entry.size, entry.sizeof_element };
+			composite->add_component (std::make_unique<nano::container_info_leaf> (info));
+		}
+
+		// Recursively convert children to composites and add them
+		for (const auto & [child_name, child] : children_m)
+		{
+			composite->add_component (child.to_legacy (child_name));
+		}
+
+		return composite;
+	}
+
+private:
+	std::list<child> children_m;
+	std::list<entry> entries_m;
+};
+}

nano/lib/observer_set.hpp

@@ -36,15 +36,19 @@ public:
 		return observers.empty ();
 	}
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const
+	size_t size () const
+	{
+		nano::lock_guard<nano::mutex> lock{ mutex };
+		return observers.size ();
+	}
+
+	nano::container_info container_info () const
 	{
 		nano::unique_lock<nano::mutex> lock{ mutex };
-		auto count = observers.size ();
-		lock.unlock ();
-		auto sizeof_element = sizeof (typename decltype (observers)::value_type);
-		auto composite = std::make_unique<container_info_composite> (name);
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "observers", count, sizeof_element }));
-		return composite;
+
+		nano::container_info info;
+		info.put ("observers", observers);
+		return info;
 	}
 
 private:

nano/lib/processing_queue.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <nano/lib/container_info.hpp>
 #include <nano/lib/locks.hpp>
 #include <nano/lib/numbers.hpp>
 #include <nano/lib/stats.hpp>
@@ -107,14 +108,13 @@ public:
 		return queue.size ();
 	}
 
-public: // Container info
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const
+	nano::container_info container_info () const
 	{
 		nano::lock_guard<nano::mutex> guard{ mutex };
 
-		auto composite = std::make_unique<container_info_composite> (name);
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "queue", queue.size (), sizeof (typename decltype (queue)::value_type) }));
-		return composite;
+		nano::container_info info;
+		info.put ("queue", queue);
+		return info;
 	}
 
 private:

nano/lib/thread_pool.cpp

@@ -89,9 +89,9 @@ void nano::thread_pool::set_thread_names (nano::thread_role::name thread_name)
 	thread_names_latch.wait ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::thread_pool::collect_container_info (std::string const & name) const
+nano::container_info nano::thread_pool::container_info () const
 {
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "count", num_queued_tasks (), sizeof (std::function<void ()>) }));
-	return composite;
+	nano::container_info info;
+	info.put ("count", num_queued_tasks ());
+	return info;
 }

nano/lib/thread_pool.hpp

@@ -37,7 +37,7 @@ public:
 	/** Returns the number of tasks which are awaiting execution by the thread pool **/
 	uint64_t num_queued_tasks () const;
 
-	std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	nano::mutex mutex;

nano/lib/uniquer.hpp

@@ -51,13 +51,13 @@ public:
 		return values.size ();
 	}
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const
+	nano::container_info container_info () const
 	{
 		nano::lock_guard<nano::mutex> guard{ mutex };
 
-		auto composite = std::make_unique<container_info_composite> (name);
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "cache", values.size (), sizeof (Value) }));
-		return composite;
+		nano::container_info info;
+		info.put ("cache", values);
+		return info;
 	}
 
 	static std::chrono::milliseconds constexpr cleanup_cutoff{ 500 };

nano/lib/utility.cpp

@@ -63,46 +63,6 @@ void nano::initialize_file_descriptor_limit ()
 	}
 }
 
-nano::container_info_composite::container_info_composite (std::string const & name) :
-	name (name)
-{
-}
-
-bool nano::container_info_composite::is_composite () const
-{
-	return true;
-}
-
-void nano::container_info_composite::add_component (std::unique_ptr<container_info_component> child)
-{
-	children.push_back (std::move (child));
-}
-
-std::vector<std::unique_ptr<nano::container_info_component>> const & nano::container_info_composite::get_children () const
-{
-	return children;
-}
-
-std::string const & nano::container_info_composite::get_name () const
-{
-	return name;
-}
-
-nano::container_info_leaf::container_info_leaf (const container_info & info) :
-	info (info)
-{
-}
-
-bool nano::container_info_leaf::is_composite () const
-{
-	return false;
-}
-
-nano::container_info const & nano::container_info_leaf::get_info () const
-{
-	return info;
-}
-
 void nano::remove_all_files_in_dir (std::filesystem::path const & dir)
 {
 	for (auto & p : std::filesystem::directory_iterator (dir))

nano/lib/utility.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <nano/lib/container_info.hpp>
 #include <nano/lib/locks.hpp>
 
 #include <boost/current_function.hpp>
@@ -55,49 +56,6 @@ namespace program_options
 
 namespace nano
 {
-/* These containers are used to collect information about sequence containers.
- * It makes use of the composite design pattern to collect information
- * from sequence containers and sequence containers inside member variables.
- */
-struct container_info
-{
-	std::string name;
-	size_t count;
-	size_t sizeof_element;
-};
-
-class container_info_component
-{
-public:
-	virtual ~container_info_component () = default;
-	virtual bool is_composite () const = 0;
-};
-
-class container_info_composite : public container_info_component
-{
-public:
-	container_info_composite (std::string const & name);
-	bool is_composite () const override;
-	void add_component (std::unique_ptr<container_info_component> child);
-	std::vector<std::unique_ptr<container_info_component>> const & get_children () const;
-	std::string const & get_name () const;
-
-private:
-	std::string name;
-	std::vector<std::unique_ptr<container_info_component>> children;
-};
-
-class container_info_leaf : public container_info_component
-{
-public:
-	container_info_leaf (container_info const & info);
-	bool is_composite () const override;
-	container_info const & get_info () const;
-
-private:
-	container_info info;
-};
-
 // Lower priority of calling work generating thread
 void work_thread_reprioritize ();
 

nano/lib/work.cpp

@@ -232,16 +232,12 @@ size_t nano::work_pool::size ()
 	return pending.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (work_pool & work_pool, std::string const & name)
+nano::container_info nano::work_pool::container_info () const
 {
-	size_t count;
-	{
-		nano::lock_guard<nano::mutex> guard{ work_pool.mutex };
-		count = work_pool.pending.size ();
-	}
-	auto sizeof_element = sizeof (decltype (work_pool.pending)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "pending", count, sizeof_element }));
-	composite->add_component (work_pool.work_observers.collect_container_info ("work_observers"));
-	return composite;
-}
+	nano::lock_guard<nano::mutex> guard{ mutex };
+
+	nano::container_info info;
+	info.put ("pending", pending);
+	info.add ("work_observers", work_observers.container_info ());
+	return info;
+}

nano/lib/work.hpp

@@ -56,12 +56,12 @@ public:
 	bool done;
 	std::vector<boost::thread> threads;
 	std::list<nano::work_item> pending;
-	nano::mutex mutex{ mutex_identifier (mutexes::work_pool) };
+	mutable nano::mutex mutex{ mutex_identifier (mutexes::work_pool) };
 	nano::condition_variable producer_condition;
 	std::chrono::nanoseconds pow_rate_limiter;
 	nano::opencl_work_func_t opencl;
 	nano::observer_set<bool> work_observers;
-};
 
-std::unique_ptr<container_info_component> collect_container_info (work_pool & work_pool, std::string const & name);
+	nano::container_info container_info () const;
+};
 }

nano/node/active_elections.cpp

@@ -589,21 +589,21 @@ void nano::active_elections::clear ()
 	vacancy_update ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (active_elections & active_elections, std::string const & name)
+nano::container_info nano::active_elections::container_info () const
 {
-	nano::lock_guard<nano::mutex> guard{ active_elections.mutex };
+	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "roots", active_elections.roots.size (), sizeof (decltype (active_elections.roots)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "election_winner_details", active_elections.election_winner_details_size (), sizeof (decltype (active_elections.election_winner_details)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "normal", static_cast<std::size_t> (active_elections.count_by_behavior[nano::election_behavior::priority]), 0 }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "hinted", static_cast<std::size_t> (active_elections.count_by_behavior[nano::election_behavior::hinted]), 0 }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "optimistic", static_cast<std::size_t> (active_elections.count_by_behavior[nano::election_behavior::optimistic]), 0 }));
+	nano::container_info info;
+	info.put ("roots", roots.size ());
+	info.put ("election_winner_details", election_winner_details_size ());
+	info.put ("normal", static_cast<std::size_t> (count_by_behavior[nano::election_behavior::priority]));
+	info.put ("hinted", static_cast<std::size_t> (count_by_behavior[nano::election_behavior::hinted]));
+	info.put ("optimistic", static_cast<std::size_t> (count_by_behavior[nano::election_behavior::optimistic]));
 
-	composite->add_component (active_elections.recently_confirmed.collect_container_info ("recently_confirmed"));
-	composite->add_component (active_elections.recently_cemented.collect_container_info ("recently_cemented"));
+	info.add ("recently_confirmed", recently_confirmed.container_info ());
+	info.add ("recently_cemented", recently_cemented.container_info ());
 
-	return composite;
+	return info;
 }
 
 /*

nano/node/active_elections.hpp

@@ -5,6 +5,7 @@
 #include <nano/node/election_behavior.hpp>
 #include <nano/node/election_insertion_result.hpp>
 #include <nano/node/election_status.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/node/recently_cemented_cache.hpp>
 #include <nano/node/recently_confirmed_cache.hpp>
 #include <nano/node/vote_router.hpp>
@@ -25,24 +26,6 @@
 
 namespace mi = boost::multi_index;
 
-namespace nano
-{
-class node;
-class active_elections;
-class block;
-class block_sideband;
-class block_processor;
-class confirming_set;
-class election;
-class vote;
-class stats;
-enum class election_state;
-}
-namespace nano::secure
-{
-class transaction;
-}
-
 namespace nano
 {
 class active_elections_config final
@@ -144,6 +127,8 @@ public:
 	void add_election_winner_details (nano::block_hash const &, std::shared_ptr<nano::election> const &);
 	std::shared_ptr<nano::election> remove_election_winner_details (nano::block_hash const &);
 
+	nano::container_info container_info () const;
+
 private:
 	void request_loop ();
 	void request_confirm (nano::unique_lock<nano::mutex> &);
@@ -164,8 +149,8 @@ private: // Dependencies
 	nano::block_processor & block_processor;
 
 public:
-	recently_confirmed_cache recently_confirmed;
-	recently_cemented_cache recently_cemented;
+	nano::recently_confirmed_cache recently_confirmed;
+	nano::recently_cemented_cache recently_cemented;
 
 	// TODO: This mutex is currently public because many tests access it
 	// TODO: This is bad. Remove the need to explicitly lock this from any code outside of this class
@@ -186,7 +171,6 @@ private:
 	std::thread thread;
 
 	friend class election;
-	friend std::unique_ptr<container_info_component> collect_container_info (active_elections &, std::string const &);
 
 public: // Tests
 	void clear ();
@@ -204,8 +188,6 @@ public: // Tests
 	friend class frontiers_confirmation_expired_optimistic_elections_removal_Test;
 };
 
-std::unique_ptr<container_info_component> collect_container_info (active_elections & active_elections, std::string const & name);
-
 nano::stat::type to_stat_type (nano::election_state);
 nano::stat::detail to_stat_detail (nano::election_state);
 }

nano/node/blockprocessor.cpp

@@ -458,25 +458,15 @@ void nano::block_processor::queue_unchecked (secure::write_transaction const & t
 	node.unchecked.trigger (hash_or_account_a);
 }
 
-std::unique_ptr<nano::container_info_component> nano::block_processor::collect_container_info (std::string const & name)
+nano::container_info nano::block_processor::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "blocks", queue.size (), 0 }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "forced", queue.size ({ nano::block_source::forced }), 0 }));
-	composite->add_component (queue.collect_container_info ("queue"));
-	return composite;
-}
-
-std::string_view nano::to_string (nano::block_source source)
-{
-	return nano::enum_util::name (source);
-}
-
-nano::stat::detail nano::to_stat_detail (nano::block_source type)
-{
-	return nano::enum_util::cast<nano::stat::detail> (type);
+	nano::container_info info;
+	info.put ("blocks", queue.size ());
+	info.put ("forced", queue.size ({ nano::block_source::forced }));
+	info.add ("queue", queue.container_info ());
+	return info;
 }
 
 /*
@@ -508,3 +498,17 @@ nano::error nano::block_processor_config::deserialize (nano::tomlconfig & toml)
 
 	return toml.get_error ();
 }
+
+/*
+ *
+ */
+
+std::string_view nano::to_string (nano::block_source source)
+{
+	return nano::enum_util::name (source);
+}
+
+nano::stat::detail nano::to_stat_detail (nano::block_source type)
+{
+	return nano::enum_util::cast<nano::stat::detail> (type);
+}

nano/node/blockprocessor.hpp

@@ -2,6 +2,7 @@
 
 #include <nano/lib/logging.hpp>
 #include <nano/node/fair_queue.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/secure/common.hpp>
 
 #include <chrono>
@@ -10,17 +11,6 @@
 #include <optional>
 #include <thread>
 
-namespace nano
-{
-class block;
-class node;
-}
-
-namespace nano::secure
-{
-class write_transaction;
-}
-
 namespace nano
 {
 enum class block_source
@@ -101,7 +91,7 @@ public:
 	void force (std::shared_ptr<nano::block> const &);
 	bool should_log ();
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
 	std::atomic<bool> flushing{ false };
 

nano/node/bootstrap/bootstrap.cpp

@@ -288,25 +288,18 @@ void nano::bootstrap_initiator::notify_listeners (bool in_progress_a)
 	}
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name)
+nano::container_info nano::bootstrap_initiator::container_info () const
 {
-	std::size_t count;
-	std::size_t cache_count;
+	nano::container_info info;
 	{
-		nano::lock_guard<nano::mutex> guard{ bootstrap_initiator.observers_mutex };
-		count = bootstrap_initiator.observers.size ();
+		nano::lock_guard<nano::mutex> guard{ observers_mutex };
+		info.put ("observers", observers.size ());
 	}
 	{
-		nano::lock_guard<nano::mutex> guard{ bootstrap_initiator.cache.pulls_cache_mutex };
-		cache_count = bootstrap_initiator.cache.cache.size ();
+		nano::lock_guard<nano::mutex> guard{ cache.pulls_cache_mutex };
+		info.put ("pulls_cache", cache.cache.size ());
 	}
-
-	auto sizeof_element = sizeof (decltype (bootstrap_initiator.observers)::value_type);
-	auto sizeof_cache_element = sizeof (decltype (bootstrap_initiator.cache.cache)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "observers", count, sizeof_element }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "pulls_cache", cache_count, sizeof_cache_element }));
-	return composite;
+	return info;
 }
 
 void nano::pulls_cache::add (nano::pull_info const & pull_a)

nano/node/bootstrap/bootstrap.hpp

@@ -53,7 +53,7 @@ public:
 	void add (nano::pull_info const &);
 	void update_pull (nano::pull_info &);
 	void remove (nano::pull_info const &);
-	nano::mutex pulls_cache_mutex;
+	mutable nano::mutex pulls_cache_mutex;
 	class account_head_tag
 	{
 	};
@@ -116,6 +116,7 @@ public:
 	nano::pulls_cache cache;
 	nano::bootstrap_attempts attempts;
 	void stop ();
+	nano::container_info container_info () const;
 
 private:
 	nano::node & node;
@@ -123,17 +124,13 @@ private:
 	void stop_attempts ();
 	std::vector<std::shared_ptr<nano::bootstrap_attempt>> attempts_list;
 	std::atomic<bool> stopped{ false };
-	nano::mutex mutex;
+	mutable nano::mutex mutex;
 	nano::condition_variable condition;
-	nano::mutex observers_mutex;
+	mutable nano::mutex observers_mutex;
 	std::vector<std::function<void (bool)>> observers;
 	std::vector<boost::thread> bootstrap_initiator_threads;
-
-	friend std::unique_ptr<container_info_component> collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name);
 };
 
-std::unique_ptr<container_info_component> collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name);
-
 /**
  * Defines the numeric values for the bootstrap feature.
  */

nano/node/bootstrap_ascending/account_sets.cpp

@@ -344,14 +344,14 @@ auto nano::bootstrap_ascending::account_sets::info () const -> nano::bootstrap_a
 	return { blocking, priorities };
 }
 
-std::unique_ptr<nano::container_info_component> nano::bootstrap_ascending::account_sets::collect_container_info (const std::string & name)
+nano::container_info nano::bootstrap_ascending::account_sets::container_info () const
 {
 	// Count blocking entries with their dependency account unknown
 	auto blocking_unknown = blocking.get<tag_dependency_account> ().count (nano::account{ 0 });
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "priorities", priorities.size (), sizeof (decltype (priorities)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "blocking", blocking.size (), sizeof (decltype (blocking)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "blocking_unknown", blocking_unknown, 0 }));
-	return composite;
-}
+	nano::container_info info;
+	info.put ("priorities", priorities);
+	info.put ("blocking", blocking);
+	info.put ("blocking_unknown", blocking_unknown);
+	return info;
+}

nano/node/bootstrap_ascending/account_sets.hpp

@@ -62,7 +62,6 @@ namespace bootstrap_ascending
 		nano::account next_priority (std::function<bool (nano::account const &)> const & filter);
 		nano::block_hash next_blocking (std::function<bool (nano::block_hash const &)> const & filter);
 
-	public:
 		bool blocked (nano::account const & account) const;
 		bool prioritized (nano::account const & account) const;
 		// Accounts in the ledger but not in priority list are assumed priority 1.0f
@@ -74,7 +73,7 @@ namespace bootstrap_ascending
 		bool priority_half_full () const;
 		bool blocked_half_full () const;
 
-		std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name);
+		nano::container_info container_info () const;
 
 	private: // Dependencies
 		account_sets_config const & config;

nano/node/bootstrap_ascending/database_scan.cpp

@@ -55,12 +55,12 @@ bool nano::bootstrap_ascending::database_scan::warmed_up () const
 	return accounts_iterator.warmed_up () && pending_iterator.warmed_up ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::bootstrap_ascending::database_scan::collect_container_info (std::string const & name) const
+nano::container_info nano::bootstrap_ascending::database_scan::container_info () const
 {
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "accounts_iterator", accounts_iterator.completed, 0 }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "pending_iterator", pending_iterator.completed, 0 }));
-	return composite;
+	nano::container_info info;
+	info.put ("accounts_iterator", accounts_iterator.completed);
+	info.put ("pending_iterator", pending_iterator.completed);
+	return info;
 }
 
 /*

nano/node/bootstrap_ascending/database_scan.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <nano/lib/container_info.hpp>
 #include <nano/lib/numbers.hpp>
 #include <nano/node/fwd.hpp>
 #include <nano/secure/pending_info.hpp>
@@ -42,7 +43,7 @@ public:
 	// Indicates if a full ledger iteration has taken place e.g. warmed up
 	bool warmed_up () const;
 
-	std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	nano::ledger & ledger;

nano/node/bootstrap_ascending/service.cpp

@@ -830,17 +830,17 @@ std::size_t nano::bootstrap_ascending::service::compute_throttle_size () const
 	return std::max (target, min_size);
 }
 
-std::unique_ptr<nano::container_info_component> nano::bootstrap_ascending::service::collect_container_info (std::string const & name)
+nano::container_info nano::bootstrap_ascending::service::container_info () const
 {
 	nano::lock_guard<nano::mutex> lock{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "tags", tags.size (), sizeof (decltype (tags)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "throttle", throttle.size (), 0 }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "throttle_successes", throttle.successes (), 0 }));
-	composite->add_component (accounts.collect_container_info ("accounts"));
-	composite->add_component (database_scan.collect_container_info ("database_scan"));
-	return composite;
+	nano::container_info info;
+	info.put ("tags", tags);
+	info.put ("throttle", throttle.size ());
+	info.put ("throttle_successes", throttle.successes ());
+	info.add ("accounts", accounts.container_info ());
+	info.add ("database_scan", database_scan.container_info ());
+	return info;
 }
 
 /*

nano/node/bootstrap_ascending/service.hpp

@@ -40,11 +40,12 @@ namespace bootstrap_ascending
 		 */
 		void process (nano::asc_pull_ack const & message, std::shared_ptr<nano::transport::channel> const &);
 
-	public: // Container info
-		std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name);
 		std::size_t blocked_size () const;
 		std::size_t priority_size () const;
 		std::size_t score_size () const;
+
+		nano::container_info container_info () const;
+
 		nano::bootstrap_ascending::account_sets::info_t info () const;
 
 	private: // Dependencies

nano/node/confirming_set.cpp

@@ -208,12 +208,12 @@ void nano::confirming_set::run_batch (std::unique_lock<std::mutex> & lock)
 	release_assert (already.empty ());
 }
 
-std::unique_ptr<nano::container_info_component> nano::confirming_set::collect_container_info (std::string const & name) const
+nano::container_info nano::confirming_set::container_info () const
 {
 	std::lock_guard guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "set", set.size (), sizeof (typename decltype (set)::value_type) }));
-	composite->add_component (notification_workers.collect_container_info ("notification_workers"));
-	return composite;
+	nano::container_info info;
+	info.put ("set", set);
+	info.add ("notification_workers", notification_workers.container_info ());
+	return info;
 }

nano/node/confirming_set.hpp

@@ -45,7 +45,7 @@ public:
 	bool exists (nano::block_hash const & hash) const;
 	std::size_t size () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 public: // Events
 	// Observers will be called once ledger has blocks marked as confirmed

nano/node/distributed_work_factory.cpp

@@ -80,11 +80,9 @@ std::size_t nano::distributed_work_factory::size () const
 	return items.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (distributed_work_factory & distributed_work, std::string const & name)
+nano::container_info nano::distributed_work_factory::container_info () const
 {
-	auto item_count = distributed_work.size ();
-	auto sizeof_item_element = sizeof (decltype (nano::distributed_work_factory::items)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "items", item_count, sizeof_item_element }));
-	return composite;
-}
+	nano::container_info info;
+	info.put ("items", size ());
+	return info;
+}

nano/node/distributed_work_factory.hpp

@@ -27,6 +27,7 @@ public:
 	void cleanup_finished ();
 	void stop ();
 	std::size_t size () const;
+	nano::container_info container_info () const;
 
 private:
 	std::unordered_multimap<nano::root, std::weak_ptr<nano::distributed_work>> items;
@@ -34,9 +35,5 @@ private:
 	nano::node & node;
 	mutable nano::mutex mutex;
 	std::atomic<bool> stopped{ false };
-
-	friend std::unique_ptr<container_info_component> collect_container_info (distributed_work_factory &, std::string const &);
 };
-
-std::unique_ptr<container_info_component> collect_container_info (distributed_work_factory & distributed_work, std::string const & name);
 }

nano/node/fair_queue.hpp

@@ -302,12 +302,12 @@ private:
 	std::chrono::steady_clock::time_point last_update{ std::chrono::steady_clock::now () };
 
 public:
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const
+	nano::container_info container_info () const
 	{
-		auto composite = std::make_unique<container_info_composite> (name);
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "queues", queues_size (), sizeof (typename decltype (queues)::value_type) }));
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "total_size", size (), sizeof (typename decltype (queues)::value_type) }));
-		return composite;
+		nano::container_info info;
+		info.put ("queues", queues);
+		info.put ("total_size", size ());
+		return info;
 	}
 };
 }

nano/node/fwd.hpp

@@ -4,12 +4,19 @@
 #include <nano/secure/fwd.hpp>
 #include <nano/store/fwd.hpp>
 
+// TODO: Move to lib/fwd.hpp
+namespace nano
+{
+class block;
+class container_info;
+}
+
 namespace nano
 {
 class active_elections;
-class block;
 class block_processor;
 class confirming_set;
+class election;
 class ledger;
 class local_block_broadcaster;
 class local_vote_history;
@@ -21,6 +28,8 @@ class node_config;
 class node_flags;
 class node_observers;
 class online_reps;
+class recently_cemented_cache;
+class recently_confirmed_cache;
 class rep_crawler;
 class rep_tiers;
 class stats;
@@ -28,8 +37,19 @@ class vote_cache;
 class vote_generator;
 class vote_processor;
 class vote_router;
+class vote_spacing;
 class wallets;
 
 enum class block_source;
+enum class election_behavior;
+enum class election_state;
 enum class vote_code;
+}
+
+namespace nano::scheduler
+{
+class hinted;
+class manual;
+class optimistic;
+class priority;
 }

nano/node/json_handler.cpp

@@ -3944,7 +3944,7 @@ void nano::json_handler::stats ()
 	}
 	else if (type == "objects")
 	{
-		construct_json (collect_container_info (node, "node").get (), response_l);
+		construct_json (node.container_info ().to_legacy ("node").get (), response_l);
 	}
 	else if (type == "database")
 	{

nano/node/local_block_broadcaster.cpp

@@ -223,11 +223,11 @@ void nano::local_block_broadcaster::cleanup (nano::unique_lock<nano::mutex> & lo
 	});
 }
 
-std::unique_ptr<nano::container_info_component> nano::local_block_broadcaster::collect_container_info (const std::string & name) const
+nano::container_info nano::local_block_broadcaster::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "local", local_blocks.size (), sizeof (decltype (local_blocks)::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("local", local_blocks);
+	return info;
 }

nano/node/local_block_broadcaster.hpp

@@ -60,7 +60,7 @@ public:
 
 	size_t size () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	void run ();

nano/node/local_vote_history.cpp

@@ -104,12 +104,11 @@ std::size_t nano::local_vote_history::size () const
 	return history.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::local_vote_history::collect_container_info (std::string const & name) const
+nano::container_info nano::local_vote_history::container_info () const
 {
-	std::size_t history_count = size ();
-	auto sizeof_element = sizeof (decltype (history)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	/* This does not currently loop over each element inside the cache to get the sizes of the votes inside history*/
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "history", history_count, sizeof_element }));
-	return composite;
-}
+	nano::lock_guard<nano::mutex> guard{ mutex };
+
+	nano::container_info info;
+	info.put ("history", history);
+	return info;
+}

nano/node/local_vote_history.hpp

@@ -2,6 +2,7 @@
 
 #include <nano/lib/locks.hpp>
 #include <nano/lib/numbers.hpp>
+#include <nano/node/fwd.hpp>
 
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
@@ -15,8 +16,6 @@ namespace mi = boost::multi_index;
 
 namespace nano
 {
-class container_info_component;
-class vote;
 class voting_constants;
 }
 
@@ -50,7 +49,7 @@ public:
 	bool exists (nano::root const &) const;
 	std::size_t size () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	// clang-format off

nano/node/message_processor.cpp

@@ -290,13 +290,13 @@ void nano::message_processor::process (nano::message const & message, std::share
 	message.visit (visitor);
 }
 
-std::unique_ptr<nano::container_info_component> nano::message_processor::collect_container_info (std::string const & name)
+nano::container_info nano::message_processor::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (queue.collect_container_info ("queue"));
-	return composite;
+	nano::container_info info;
+	info.add ("queue", queue.container_info ());
+	return info;
 }
 
 /*

nano/node/message_processor.hpp

@@ -36,7 +36,7 @@ public:
 	bool put (std::unique_ptr<nano::message>, std::shared_ptr<nano::transport::channel> const &);
 	void process (nano::message const &, std::shared_ptr<nano::transport::channel> const &);
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
 private:
 	void run ();
@@ -53,7 +53,7 @@ private:
 	nano::fair_queue<entry_t, nano::no_value> queue;
 
 	std::atomic<bool> stopped{ false };
-	nano::mutex mutex;
+	mutable nano::mutex mutex;
 	nano::condition_variable condition;
 	std::vector<std::thread> threads;
 };

nano/node/network.cpp

@@ -575,6 +575,15 @@ nano::node_id_handshake::response_payload nano::network::prepare_handshake_respo
 	return response;
 }
 
+nano::container_info nano::network::container_info () const
+{
+	nano::container_info info;
+	info.add ("tcp_channels", tcp_channels.container_info ());
+	info.add ("syn_cookies", syn_cookies.container_info ());
+	info.add ("excluded_peers", excluded_peers.container_info ());
+	return info;
+}
+
 /*
  * syn_cookies
  */
@@ -682,32 +691,18 @@ std::optional<nano::uint256_union> nano::syn_cookies::cookie (const nano::endpoi
 	return std::nullopt;
 }
 
-std::size_t nano::syn_cookies::cookies_size ()
+std::size_t nano::syn_cookies::cookies_size () const
 {
 	nano::lock_guard<nano::mutex> lock{ syn_cookie_mutex };
 	return cookies.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (network & network, std::string const & name)
+nano::container_info nano::syn_cookies::container_info () const
 {
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (network.tcp_channels.collect_container_info ("tcp_channels"));
-	composite->add_component (network.syn_cookies.collect_container_info ("syn_cookies"));
-	composite->add_component (network.excluded_peers.collect_container_info ("excluded_peers"));
-	return composite;
-}
+	nano::lock_guard<nano::mutex> syn_cookie_guard{ syn_cookie_mutex };
 
-std::unique_ptr<nano::container_info_component> nano::syn_cookies::collect_container_info (std::string const & name)
-{
-	std::size_t syn_cookies_count;
-	std::size_t syn_cookies_per_ip_count;
-	{
-		nano::lock_guard<nano::mutex> syn_cookie_guard{ syn_cookie_mutex };
-		syn_cookies_count = cookies.size ();
-		syn_cookies_per_ip_count = cookies_per_ip.size ();
-	}
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "syn_cookies", syn_cookies_count, sizeof (decltype (cookies)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "syn_cookies_per_ip", syn_cookies_per_ip_count, sizeof (decltype (cookies_per_ip)::value_type) }));
-	return composite;
-}
+	nano::container_info info;
+	info.put ("syn_cookies", cookies.size ());
+	info.put ("syn_cookies_per_ip", cookies_per_ip.size ());
+	return info;
+}

nano/node/network.hpp

@@ -34,9 +34,8 @@ public:
 	bool validate (nano::endpoint const &, nano::account const &, nano::signature const &);
 	/** Get cookie associated with endpoint and erases that cookie from this container */
 	std::optional<nano::uint256_union> cookie (nano::endpoint const &);
-
-	std::unique_ptr<container_info_component> collect_container_info (std::string const &);
-	std::size_t cookies_size ();
+	std::size_t cookies_size () const;
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	nano::logger & logger;
@@ -130,6 +129,8 @@ public:
 	void exclude (std::shared_ptr<nano::transport::channel> const & channel);
 	void inbound (nano::message const &, std::shared_ptr<nano::transport::channel> const &);
 
+	nano::container_info container_info () const;
+
 public: // Handshake
 	/** Verifies that handshake response matches our query. @returns true if OK */
 	bool verify_handshake_response (nano::node_id_handshake::response_payload const & response, nano::endpoint const & remote_endpoint);
@@ -176,6 +177,4 @@ public:
 	static std::size_t confirm_req_hashes_max;
 	static std::size_t confirm_ack_hashes_max;
 };
-
-std::unique_ptr<container_info_component> collect_container_info (network & network, std::string const & name);
 }

nano/node/node.cpp

@@ -518,46 +518,6 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a)
 	});
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (node & node, std::string const & name)
-{
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (collect_container_info (node.work, "work"));
-	composite->add_component (node.ledger.collect_container_info ("ledger"));
-	composite->add_component (collect_container_info (node.active, "active"));
-	composite->add_component (collect_container_info (node.bootstrap_initiator, "bootstrap_initiator"));
-	composite->add_component (node.tcp_listener.collect_container_info ("tcp_listener"));
-	composite->add_component (collect_container_info (node.network, "network"));
-	composite->add_component (node.telemetry.collect_container_info ("telemetry"));
-	composite->add_component (node.workers.collect_container_info ("workers"));
-	composite->add_component (node.bootstrap_workers.collect_container_info ("bootstrap_workers"));
-	composite->add_component (node.wallet_workers.collect_container_info ("wallet_workers"));
-	composite->add_component (node.election_workers.collect_container_info ("election_workers"));
-	composite->add_component (collect_container_info (node.observers, "observers"));
-	composite->add_component (collect_container_info (node.wallets, "wallets"));
-	composite->add_component (node.vote_processor.collect_container_info ("vote_processor"));
-	composite->add_component (node.vote_cache_processor.collect_container_info ("vote_cache_processor"));
-	composite->add_component (node.rep_crawler.collect_container_info ("rep_crawler"));
-	composite->add_component (node.block_processor.collect_container_info ("block_processor"));
-	composite->add_component (collect_container_info (node.online_reps, "online_reps"));
-	composite->add_component (node.history.collect_container_info ("history"));
-	composite->add_component (node.block_uniquer.collect_container_info ("block_uniquer"));
-	composite->add_component (node.vote_uniquer.collect_container_info ("vote_uniquer"));
-	composite->add_component (node.confirming_set.collect_container_info ("confirming_set"));
-	composite->add_component (collect_container_info (node.distributed_work, "distributed_work"));
-	composite->add_component (node.aggregator.collect_container_info ("request_aggregator"));
-	composite->add_component (node.scheduler.collect_container_info ("election_scheduler"));
-	composite->add_component (node.vote_cache.collect_container_info ("vote_cache"));
-	composite->add_component (node.vote_router.collect_container_info ("vote_router"));
-	composite->add_component (node.generator.collect_container_info ("vote_generator"));
-	composite->add_component (node.final_generator.collect_container_info ("vote_generator_final"));
-	composite->add_component (node.ascendboot.collect_container_info ("bootstrap_ascending"));
-	composite->add_component (node.unchecked.collect_container_info ("unchecked"));
-	composite->add_component (node.local_block_broadcaster.collect_container_info ("local_block_broadcaster"));
-	composite->add_component (node.rep_tiers.collect_container_info ("rep_tiers"));
-	composite->add_component (node.message_processor.collect_container_info ("message_processor"));
-	return composite;
-}
-
 void nano::node::process_active (std::shared_ptr<nano::block> const & incoming)
 {
 	block_processor.add (incoming);
@@ -1305,6 +1265,59 @@ std::string nano::node::make_logger_identifier (const nano::keypair & node_id)
 	return node_id.pub.to_node_id ().substr (0, 10);
 }
 
+nano::container_info nano::node::container_info () const
+{
+	/*
+	 * TODO: Add container infos for:
+	 * - bootstrap_server
+	 * - peer_history
+	 * - port_mapping
+	 * - epoch_upgrader
+	 * - websocket
+	 */
+
+	nano::container_info info;
+	info.add ("work", work.container_info ());
+	info.add ("ledger", ledger.container_info ());
+	info.add ("active", active.container_info ());
+	info.add ("bootstrap_initiator", bootstrap_initiator.container_info ());
+	info.add ("tcp_listener", tcp_listener.container_info ());
+	info.add ("network", network.container_info ());
+	info.add ("telemetry", telemetry.container_info ());
+	info.add ("workers", workers.container_info ());
+	info.add ("bootstrap_workers", bootstrap_workers.container_info ());
+	info.add ("wallet_workers", wallet_workers.container_info ());
+	info.add ("election_workers", election_workers.container_info ());
+	info.add ("observers", observers.container_info ());
+	info.add ("wallets", wallets.container_info ());
+	info.add ("vote_processor", vote_processor.container_info ());
+	info.add ("vote_cache_processor", vote_cache_processor.container_info ());
+	info.add ("rep_crawler", rep_crawler.container_info ());
+	info.add ("block_processor", block_processor.container_info ());
+	info.add ("online_reps", online_reps.container_info ());
+	info.add ("history", history.container_info ());
+	info.add ("block_uniquer", block_uniquer.container_info ());
+	info.add ("vote_uniquer", vote_uniquer.container_info ());
+	info.add ("confirming_set", confirming_set.container_info ());
+	info.add ("distributed_work", distributed_work.container_info ());
+	info.add ("aggregator", aggregator.container_info ());
+	info.add ("scheduler", scheduler.container_info ());
+	info.add ("vote_cache", vote_cache.container_info ());
+	info.add ("vote_router", vote_router.container_info ());
+	info.add ("generator", generator.container_info ());
+	info.add ("final_generator", final_generator.container_info ());
+	info.add ("bootstrap_ascending", ascendboot.container_info ());
+	info.add ("unchecked", unchecked.container_info ());
+	info.add ("local_block_broadcaster", local_block_broadcaster.container_info ());
+	info.add ("rep_tiers", rep_tiers.container_info ());
+	info.add ("message_processor", message_processor.container_info ());
+	return info;
+}
+
+/*
+ *
+ */
+
 nano::keypair nano::load_or_create_node_id (std::filesystem::path const & application_path)
 {
 	auto node_private_key_path = application_path / "node_id_private.key";

nano/node/node.hpp

@@ -142,6 +142,7 @@ public:
 	nano::account get_node_id () const;
 	nano::telemetry_data local_telemetry () const;
 	std::string identifier () const;
+	nano::container_info container_info () const;
 
 public:
 	const nano::keypair node_id;
@@ -260,8 +261,6 @@ private:
 
 nano::keypair load_or_create_node_id (std::filesystem::path const & application_path);
 
-std::unique_ptr<container_info_component> collect_container_info (node & node, std::string const & name);
-
 nano::node_flags const & inactive_node_flag_defaults ();
 
 }

nano/node/node_observers.cpp

@@ -1,16 +1,18 @@
 #include <nano/node/node_observers.hpp>
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (nano::node_observers & node_observers, std::string const & name)
+nano::container_info nano::node_observers::container_info () const
 {
-	auto composite = std::make_unique<nano::container_info_composite> (name);
-	composite->add_component (node_observers.blocks.collect_container_info ("blocks"));
-	composite->add_component (node_observers.wallet.collect_container_info ("wallet"));
-	composite->add_component (node_observers.vote.collect_container_info ("vote"));
-	composite->add_component (node_observers.active_started.collect_container_info ("active_started"));
-	composite->add_component (node_observers.active_stopped.collect_container_info ("active_stopped"));
-	composite->add_component (node_observers.account_balance.collect_container_info ("account_balance"));
-	composite->add_component (node_observers.endpoint.collect_container_info ("endpoint"));
-	composite->add_component (node_observers.disconnect.collect_container_info ("disconnect"));
-	composite->add_component (node_observers.work_cancel.collect_container_info ("work_cancel"));
-	return composite;
+	nano::container_info info;
+	info.put ("blocks", blocks.size ());
+	info.put ("wallet", wallet.size ());
+	info.put ("vote", vote.size ());
+	info.put ("active_started", active_started.size ());
+	info.put ("active_stopped", active_stopped.size ());
+	info.put ("account_balance", account_balance.size ());
+	info.put ("endpoint", endpoint.size ());
+	info.put ("disconnect", disconnect.size ());
+	info.put ("work_cancel", work_cancel.size ());
+	info.put ("telemetry", telemetry.size ());
+	info.put ("socket_connected", socket_connected.size ());
+	return info;
 }

nano/node/node_observers.hpp

@@ -34,7 +34,7 @@ public:
 	nano::observer_set<nano::root const &> work_cancel;
 	nano::observer_set<nano::telemetry_data const &, std::shared_ptr<nano::transport::channel> const &> telemetry;
 	nano::observer_set<nano::transport::tcp_socket &> socket_connected;
-};
 
-std::unique_ptr<container_info_component> collect_container_info (node_observers & node_observers, std::string const & name);
+	nano::container_info container_info () const;
+};
 }

nano/node/online_reps.cpp

@@ -117,16 +117,11 @@ void nano::online_reps::clear ()
 	online_m = 0;
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (online_reps & online_reps, std::string const & name)
+nano::container_info nano::online_reps::container_info () const
 {
-	std::size_t count;
-	{
-		nano::lock_guard<nano::mutex> guard{ online_reps.mutex };
-		count = online_reps.reps.size ();
-	}
+	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto sizeof_element = sizeof (decltype (online_reps.reps)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "reps", count, sizeof_element }));
-	return composite;
+	nano::container_info info;
+	info.put ("reps", reps);
+	return info;
 }

nano/node/online_reps.hpp

@@ -39,6 +39,9 @@ public:
 	/** List of online representatives, both the currently sampling ones and the ones observed in the previous sampling period */
 	std::vector<nano::account> list ();
 	void clear ();
+	nano::container_info container_info () const;
+
+public:
 	static unsigned constexpr online_weight_quorum = 67;
 
 private:
@@ -71,8 +74,5 @@ private:
 	nano::uint128_t minimum;
 
 	friend class election_quorum_minimum_update_weight_before_quorum_checks_Test;
-	friend std::unique_ptr<container_info_component> collect_container_info (online_reps & online_reps, std::string const & name);
 };
-
-std::unique_ptr<container_info_component> collect_container_info (online_reps & online_reps, std::string const & name);
 }

nano/node/peer_exclusion.cpp

@@ -97,11 +97,11 @@ std::size_t nano::peer_exclusion::size () const
 	return peers.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::peer_exclusion::collect_container_info (std::string const & name)
+nano::container_info nano::peer_exclusion::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "peers", peers.size (), sizeof (decltype (peers)::value_type) }));
-	return composite;
-}
+	nano::container_info info;
+	info.put ("peers", peers.size ());
+	return info;
+}

nano/node/peer_exclusion.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <nano/node/common.hpp>
 
 #include <boost/multi_index/hashed_index.hpp>
@@ -54,6 +56,6 @@ public:
 	void remove (nano::tcp_endpoint const &);
 	std::size_t size () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 };
 }

nano/node/recently_cemented_cache.cpp

@@ -32,11 +32,11 @@ std::size_t nano::recently_cemented_cache::size () const
 	return cemented.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::recently_cemented_cache::collect_container_info (const std::string & name)
+nano::container_info nano::recently_cemented_cache::container_info () const
 {
-	nano::unique_lock<nano::mutex> lock{ mutex };
+	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "cemented", cemented.size (), sizeof (decltype (cemented)::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("cemented", cemented);
+	return info;
 }

nano/node/recently_cemented_cache.hpp

@@ -26,13 +26,12 @@ public:
 	queue_t list () const;
 	std::size_t size () const;
 
+	nano::container_info container_info () const;
+
 private:
 	queue_t cemented;
 	std::size_t const max_size;
 
 	mutable nano::mutex mutex;
-
-public: // Container info
-	std::unique_ptr<container_info_component> collect_container_info (std::string const &);
 };
 }

nano/node/recently_confirmed_cache.cpp

@@ -56,11 +56,11 @@ nano::recently_confirmed_cache::entry_t nano::recently_confirmed_cache::back ()
 	return confirmed.back ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::recently_confirmed_cache::collect_container_info (const std::string & name)
+nano::container_info nano::recently_confirmed_cache::container_info () const
 {
-	nano::unique_lock<nano::mutex> lock{ mutex };
+	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "confirmed", confirmed.size (), sizeof (decltype (confirmed)::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("confirmed", confirmed);
+	return info;
 }

nano/node/recently_confirmed_cache.hpp

@@ -34,6 +34,8 @@ public:
 	bool exists (nano::qualified_root const &) const;
 	bool exists (nano::block_hash const &) const;
 
+	nano::container_info container_info () const;
+
 public: // Tests
 	entry_t back () const;
 
@@ -56,8 +58,5 @@ private:
 	std::size_t const max_size;
 
 	mutable nano::mutex mutex;
-
-public: // Container info
-	std::unique_ptr<container_info_component> collect_container_info (std::string const &);
 };
 }

nano/node/rep_tiers.cpp

@@ -118,6 +118,7 @@ void nano::rep_tiers::calculate_tiers ()
 
 	stats.add (nano::stat::type::rep_tiers, nano::stat::detail::processed, nano::stat::dir::in, rep_amounts.size ());
 	stats.add (nano::stat::type::rep_tiers, nano::stat::detail::ignored, nano::stat::dir::in, ignored);
+
 	logger.debug (nano::log::type::rep_tiers, "Representative tiers updated, tier 1: {}, tier 2: {}, tier 3: {} ({} ignored)",
 	representatives_1_l.size (),
 	representatives_2_l.size (),
@@ -134,14 +135,15 @@ void nano::rep_tiers::calculate_tiers ()
 	stats.inc (nano::stat::type::rep_tiers, nano::stat::detail::updated);
 }
 
-std::unique_ptr<nano::container_info_component> nano::rep_tiers::collect_container_info (const std::string & name)
+nano::container_info nano::rep_tiers::container_info () const
 {
 	nano::lock_guard<nano::mutex> lock{ mutex };
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "representatives_1", representatives_1.size (), sizeof (decltype (representatives_1)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "representatives_2", representatives_2.size (), sizeof (decltype (representatives_2)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "representatives_3", representatives_3.size (), sizeof (decltype (representatives_3)::value_type) }));
-	return composite;
+
+	nano::container_info info;
+	info.put ("tier_1", representatives_1);
+	info.put ("tier_2", representatives_2);
+	info.put ("tier_3", representatives_3);
+	return info;
 }
 
 nano::stat::detail nano::to_stat_detail (nano::rep_tier tier)

nano/node/rep_tiers.hpp

@@ -40,7 +40,7 @@ public:
 	/** Returns the representative tier for the account */
 	nano::rep_tier tier (nano::account const & representative) const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	nano::ledger & ledger;

nano/node/repcrawler.cpp

@@ -435,7 +435,7 @@ nano::uint128_t nano::rep_crawler::total_weight () const
 	return result;
 }
 
-std::vector<nano::representative> nano::rep_crawler::representatives (std::size_t count, nano::uint128_t const minimum_weight, std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version)
+std::vector<nano::representative> nano::rep_crawler::representatives (std::size_t count, nano::uint128_t const minimum_weight, std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version) const
 {
 	auto const version_min = minimum_protocol_version.value_or (node.network_params.network.protocol_version_min);
 
@@ -460,28 +460,17 @@ std::vector<nano::representative> nano::rep_crawler::representatives (std::size_
 	return result;
 }
 
-std::vector<nano::representative> nano::rep_crawler::principal_representatives (std::size_t count, std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version)
+std::vector<nano::representative> nano::rep_crawler::principal_representatives (std::size_t count, std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version) const
 {
 	return representatives (count, node.minimum_principal_weight (), minimum_protocol_version);
 }
 
-std::size_t nano::rep_crawler::representative_count ()
+std::size_t nano::rep_crawler::representative_count () const
 {
 	nano::lock_guard<nano::mutex> lock{ mutex };
 	return reps.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::rep_crawler::collect_container_info (const std::string & name)
-{
-	nano::lock_guard<nano::mutex> guard{ mutex };
-
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "reps", reps.size (), sizeof (decltype (reps)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "queries", queries.size (), sizeof (decltype (queries)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "responses", responses.size (), sizeof (decltype (responses)::value_type) }));
-	return composite;
-}
-
 // Only for tests
 void nano::rep_crawler::force_add_rep (const nano::account & account, const std::shared_ptr<nano::transport::channel> & channel)
 {
@@ -506,6 +495,17 @@ void nano::rep_crawler::force_query (const nano::block_hash & hash, const std::s
 	queries.emplace (query_entry{ hash, channel });
 }
 
+nano::container_info nano::rep_crawler::container_info () const
+{
+	nano::lock_guard<nano::mutex> guard{ mutex };
+
+	nano::container_info info;
+	info.put ("reps", reps);
+	info.put ("queries", queries);
+	info.put ("responses", responses);
+	return info;
+}
+
 /*
  * rep_crawler_config
  */

nano/node/repcrawler.hpp

@@ -76,16 +76,16 @@ public:
 
 	/** Request a list of the top \p count known representatives in descending order of weight, with at least \p weight_a voting weight, and optionally with a minimum version \p minimum_protocol_version
 	 */
-	std::vector<representative> representatives (std::size_t count = std::numeric_limits<std::size_t>::max (), nano::uint128_t minimum_weight = 0, std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version = {});
+	std::vector<representative> representatives (std::size_t count = std::numeric_limits<std::size_t>::max (), nano::uint128_t minimum_weight = 0, std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version = {}) const;
 
 	/** Request a list of the top \p count known principal representatives in descending order of weight, optionally with a minimum version \p minimum_protocol_version
 	 */
-	std::vector<representative> principal_representatives (std::size_t count = std::numeric_limits<std::size_t>::max (), std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version = {});
+	std::vector<representative> principal_representatives (std::size_t count = std::numeric_limits<std::size_t>::max (), std::optional<decltype (nano::network_constants::protocol_version)> const & minimum_protocol_version = {}) const;
 
 	/** Total number of representatives */
-	std::size_t representative_count ();
+	std::size_t representative_count () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	rep_crawler_config const & config;

nano/node/request_aggregator.cpp

@@ -291,13 +291,13 @@ auto nano::request_aggregator::aggregate (nano::secure::transaction const & tran
 	};
 }
 
-std::unique_ptr<nano::container_info_component> nano::request_aggregator::collect_container_info (std::string const & name) const
+nano::container_info nano::request_aggregator::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (queue.collect_container_info ("queue"));
-	return composite;
+	nano::container_info info;
+	info.add ("queue", queue.container_info ());
+	return info;
 }
 
 /*

nano/node/request_aggregator.hpp

@@ -51,7 +51,6 @@ public:
 	void start ();
 	void stop ();
 
-public:
 	using request_type = std::vector<std::pair<nano::block_hash, nano::root>>;
 
 	/** Add a new request by \p channel_a for hashes \p hashes_roots_a */
@@ -61,7 +60,7 @@ public:
 	std::size_t size () const;
 	bool empty () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	void run ();

nano/node/scheduler/component.cpp

@@ -37,12 +37,12 @@ void nano::scheduler::component::stop ()
 	priority.stop ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::scheduler::component::collect_container_info (std::string const & name)
+nano::container_info nano::scheduler::component::container_info () const
 {
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (hinted.collect_container_info ("hinted"));
-	composite->add_component (manual.collect_container_info ("manual"));
-	composite->add_component (optimistic.collect_container_info ("optimistic"));
-	composite->add_component (priority.collect_container_info ("priority"));
-	return composite;
+	nano::container_info info;
+	info.add ("hinted", hinted.container_info ());
+	info.add ("manual", manual.container_info ());
+	info.add ("optimistic", optimistic.container_info ());
+	info.add ("priority", priority.container_info ());
+	return info;
 }

nano/node/scheduler/component.hpp

@@ -1,27 +1,14 @@
 #pragma once
 
+#include <nano/node/fwd.hpp>
+
 #include <memory>
 #include <string>
 
-namespace nano
-{
-class container_info_component;
-class node;
-}
 namespace nano::scheduler
 {
-class hinted;
-class manual;
-class optimistic;
-class priority;
-
 class component final
 {
-	std::unique_ptr<nano::scheduler::hinted> hinted_impl;
-	std::unique_ptr<nano::scheduler::manual> manual_impl;
-	std::unique_ptr<nano::scheduler::optimistic> optimistic_impl;
-	std::unique_ptr<nano::scheduler::priority> priority_impl;
-
 public:
 	explicit component (nano::node & node);
 	~component ();
@@ -31,8 +18,15 @@ public:
 	// Stops all schedulers
 	void stop ();
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
+private:
+	std::unique_ptr<nano::scheduler::hinted> hinted_impl;
+	std::unique_ptr<nano::scheduler::manual> manual_impl;
+	std::unique_ptr<nano::scheduler::optimistic> optimistic_impl;
+	std::unique_ptr<nano::scheduler::priority> priority_impl;
+
+public: // Schedulers
 	nano::scheduler::hinted & hinted;
 	nano::scheduler::manual & manual;
 	nano::scheduler::optimistic & optimistic;

nano/node/scheduler/hinted.cpp

@@ -236,13 +236,13 @@ bool nano::scheduler::hinted::cooldown (const nano::block_hash & hash)
 	return false; // No need to cooldown
 }
 
-std::unique_ptr<nano::container_info_component> nano::scheduler::hinted::collect_container_info (const std::string & name) const
+nano::container_info nano::scheduler::hinted::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "cooldowns", cooldowns_m.size (), sizeof (decltype (cooldowns_m)::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("cooldowns", cooldowns_m);
+	return info;
 }
 
 /*

nano/node/scheduler/hinted.hpp

@@ -2,6 +2,7 @@
 
 #include <nano/lib/locks.hpp>
 #include <nano/lib/numbers.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/secure/common.hpp>
 #include <nano/store/transaction.hpp>
 
@@ -16,20 +17,6 @@
 
 namespace mi = boost::multi_index;
 
-namespace nano
-{
-class node;
-class node_config;
-class active_elections;
-class vote_cache;
-class online_reps;
-}
-namespace nano::secure
-{
-class transaction;
-class read_transaction;
-}
-
 namespace nano::scheduler
 {
 class hinted_config final
@@ -65,7 +52,7 @@ public:
 	 */
 	void notify ();
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	bool predicate () const;

nano/node/scheduler/manual.cpp

@@ -86,11 +86,11 @@ void nano::scheduler::manual::run ()
 	}
 }
 
-std::unique_ptr<nano::container_info_component> nano::scheduler::manual::collect_container_info (std::string const & name) const
+nano::container_info nano::scheduler::manual::container_info () const
 {
-	nano::unique_lock<nano::mutex> lock{ mutex };
+	nano::lock_guard<nano::mutex> lock{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "queue", queue.size (), sizeof (decltype (queue)::value_type) }));
-	return composite;
-}
+	nano::container_info info;
+	info.put ("queue", queue);
+	return info;
+}

nano/node/scheduler/manual.hpp

@@ -1,6 +1,8 @@
 #pragma once
+
 #include <nano/lib/locks.hpp>
 #include <nano/lib/numbers.hpp>
+#include <nano/node/fwd.hpp>
 
 #include <boost/optional.hpp>
 
@@ -8,16 +10,10 @@
 #include <memory>
 #include <mutex>
 
-namespace nano
-{
-class block;
-enum class election_behavior;
-class node;
-}
-
 namespace nano::scheduler
 {
 class buckets;
+
 class manual final
 {
 	std::deque<std::tuple<std::shared_ptr<nano::block>, boost::optional<nano::uint128_t>, nano::election_behavior>> queue;
@@ -31,7 +27,7 @@ class manual final
 	void run ();
 
 public:
-	manual (nano::node & node);
+	explicit manual (nano::node & node);
 	~manual ();
 
 	void start ();
@@ -41,6 +37,6 @@ public:
 	// Call action with confirmed block, may be different than what we started with
 	void push (std::shared_ptr<nano::block> const &, boost::optional<nano::uint128_t> const & = boost::none);
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
-}; // class manual
-} // nano::scheduler
+	nano::container_info container_info () const;
+};
+}

nano/node/scheduler/optimistic.cpp

@@ -168,13 +168,13 @@ void nano::scheduler::optimistic::run_one (secure::transaction const & transacti
 	}
 }
 
-std::unique_ptr<nano::container_info_component> nano::scheduler::optimistic::collect_container_info (const std::string & name) const
+nano::container_info nano::scheduler::optimistic::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "candidates", candidates.size (), sizeof (decltype (candidates)::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("candidates", candidates);
+	return info;
 }
 
 /*

nano/node/scheduler/optimistic.hpp

@@ -4,6 +4,7 @@
 #include <nano/lib/numbers.hpp>
 #include <nano/lib/timer.hpp>
 #include <nano/lib/utility.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/secure/common.hpp>
 
 #include <boost/multi_index/hashed_index.hpp>
@@ -20,14 +21,6 @@
 
 namespace mi = boost::multi_index;
 
-namespace nano
-{
-class account_info;
-class active_elections;
-class ledger;
-class node;
-}
-
 namespace nano::scheduler
 {
 class optimistic_config final
@@ -67,7 +60,7 @@ public:
 	 */
 	void notify ();
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	bool activate_predicate (nano::account_info const &, nano::confirmation_height_info const &) const;

nano/node/scheduler/priority.cpp

@@ -229,30 +229,30 @@ auto nano::scheduler::priority::find_bucket (nano::uint128_t priority) -> bucket
 	return **it;
 }
 
-std::unique_ptr<nano::container_info_component> nano::scheduler::priority::collect_container_info (std::string const & name) const
+nano::container_info nano::scheduler::priority::container_info () const
 {
 	auto collect_blocks = [&] () {
-		auto composite = std::make_unique<container_info_composite> ("blocks");
+		nano::container_info info;
 		for (auto i = 0; i < buckets.size (); ++i)
 		{
 			auto const & bucket = buckets[i];
-			composite->add_component (std::make_unique<container_info_leaf> (container_info{ std::to_string (i), bucket->size (), 0 }));
+			info.put (std::to_string (i), bucket->size ());
 		}
-		return composite;
+		return info;
 	};
 
 	auto collect_elections = [&] () {
-		auto composite = std::make_unique<container_info_composite> ("elections");
+		nano::container_info info;
 		for (auto i = 0; i < buckets.size (); ++i)
 		{
 			auto const & bucket = buckets[i];
-			composite->add_component (std::make_unique<container_info_leaf> (container_info{ std::to_string (i), bucket->election_count (), 0 }));
+			info.put (std::to_string (i), bucket->election_count ());
 		}
-		return composite;
+		return info;
 	};
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (collect_blocks ());
-	composite->add_component (collect_elections ());
-	return composite;
-}
+	nano::container_info info;
+	info.add ("blocks", collect_blocks ());
+	info.add ("elections", collect_elections ());
+	return info;
+}

nano/node/scheduler/priority.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <nano/lib/numbers.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/node/scheduler/bucket.hpp>
 
 #include <condition_variable>
@@ -9,22 +10,10 @@
 #include <string>
 #include <thread>
 
-namespace nano
-{
-class account_info;
-class confirmation_height_info;
-class block;
-class container_info_component;
-class node;
-class stats;
-}
-namespace nano::secure
-{
-class transaction;
-}
-
 namespace nano::scheduler
 {
+class buckets;
+
 class priority_config
 {
 public:
@@ -34,7 +23,6 @@ public:
 	bool enabled{ true };
 };
 
-class buckets;
 class priority final
 {
 public:
@@ -55,7 +43,7 @@ public:
 	std::size_t size () const;
 	bool empty () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	priority_config const & config;

nano/node/telemetry.cpp

@@ -289,11 +289,11 @@ std::unordered_map<nano::endpoint, nano::telemetry_data> nano::telemetry::get_al
 	return result;
 }
 
-std::unique_ptr<nano::container_info_component> nano::telemetry::collect_container_info (const std::string & name)
+nano::container_info nano::telemetry::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "telemetries", telemetries.size (), sizeof (decltype (telemetries)::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("telemetries", telemetries.size ());
+	return info;
 }

nano/node/telemetry.hpp

@@ -2,6 +2,7 @@
 
 #include <nano/lib/utility.hpp>
 #include <nano/node/common.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/node/messages.hpp>
 #include <nano/node/nodeconfig.hpp>
 #include <nano/secure/common.hpp>
@@ -20,18 +21,6 @@ namespace mi = boost::multi_index;
 
 namespace nano
 {
-class node;
-class network;
-class node_observers;
-class stats;
-class ledger;
-class thread_pool;
-class unchecked_map;
-namespace transport
-{
-	class channel;
-}
-
 class telemetry_config final
 {
 public:
@@ -84,8 +73,7 @@ public:
 	 */
 	std::unordered_map<nano::endpoint, nano::telemetry_data> get_all_telemetries () const;
 
-public: // Container info
-	std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	telemetry_config const config;

nano/node/transport/fwd.hpp

@@ -5,5 +5,6 @@ namespace nano::transport
 class channel;
 class tcp_channel;
 class tcp_channels;
+class tcp_server;
 class tcp_socket;
 }

nano/node/transport/tcp_channels.cpp

@@ -312,23 +312,6 @@ bool nano::transport::tcp_channels::track_reachout (nano::endpoint const & endpo
 	return inserted;
 }
 
-std::unique_ptr<nano::container_info_component> nano::transport::tcp_channels::collect_container_info (std::string const & name)
-{
-	std::size_t channels_count;
-	std::size_t attemps_count;
-	{
-		nano::lock_guard<nano::mutex> guard{ mutex };
-		channels_count = channels.size ();
-		attemps_count = attempts.size ();
-	}
-
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "channels", channels_count, sizeof (decltype (channels)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "attempts", attemps_count, sizeof (decltype (attempts)::value_type) }));
-
-	return composite;
-}
-
 void nano::transport::tcp_channels::purge (std::chrono::steady_clock::time_point cutoff_deadline)
 {
 	nano::lock_guard<nano::mutex> lock{ mutex };
@@ -449,4 +432,14 @@ void nano::transport::tcp_channels::modify (std::shared_ptr<nano::transport::tcp
 void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint)
 {
 	node.tcp_listener.connect (endpoint.address (), endpoint.port ());
+}
+
+nano::container_info nano::transport::tcp_channels::container_info () const
+{
+	nano::lock_guard<nano::mutex> guard{ mutex };
+
+	nano::container_info info;
+	info.put ("channels", channels.size ());
+	info.put ("attempts", attempts.size ());
+	return info;
 }

nano/node/transport/tcp_channels.hpp

@@ -48,7 +48,6 @@ public:
 	bool max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a);
 	// Should we reach out to this endpoint with a keepalive message? If yes, register a new reachout attempt
 	bool track_reachout (nano::endpoint const &);
-	std::unique_ptr<container_info_component> collect_container_info (std::string const &);
 	void purge (std::chrono::steady_clock::time_point cutoff_deadline);
 	void list (std::deque<std::shared_ptr<nano::transport::channel>> &, uint8_t = 0, bool = true);
 	void modify (std::shared_ptr<nano::transport::tcp_channel> const &, std::function<void (std::shared_ptr<nano::transport::tcp_channel> const &)>);
@@ -58,6 +57,8 @@ public:
 	// Connection start
 	void start_tcp (nano::endpoint const &);
 
+	nano::container_info container_info () const;
+
 private: // Dependencies
 	nano::node & node;
 

nano/node/transport/tcp_listener.cpp

@@ -601,12 +601,14 @@ auto nano::transport::tcp_listener::servers () const -> std::vector<std::shared_
 	return { r.begin (), r.end () };
 }
 
-std::unique_ptr<nano::container_info_component> nano::transport::tcp_listener::collect_container_info (std::string const & name)
+nano::container_info nano::transport::tcp_listener::container_info () const
 {
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "connections", connection_count (), sizeof (decltype (connections)::value_type) }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "attempts", attempt_count (), sizeof (decltype (attempts)::value_type) }));
-	return composite;
+	nano::lock_guard<nano::mutex> lock{ mutex };
+
+	nano::container_info info;
+	info.put ("connections", connections.size ());
+	info.put ("attempts", attempts.size ());
+	return info;
 }
 
 /*

nano/node/transport/tcp_listener.hpp

@@ -22,9 +22,6 @@ namespace asio = boost::asio;
 
 namespace nano::transport
 {
-class socket;
-class tcp_server;
-
 class tcp_config
 {
 public:
@@ -84,7 +81,7 @@ public:
 	std::vector<std::shared_ptr<nano::transport::tcp_socket>> sockets () const;
 	std::vector<std::shared_ptr<nano::transport::tcp_server>> servers () const;
 
-	std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name);
+	nano::container_info container_info () const;
 
 public: // Events
 	using connection_accepted_event_t = nano::observer_set<std::shared_ptr<nano::transport::tcp_socket> const &, std::shared_ptr<nano::transport::tcp_server>>;

nano/node/unchecked_map.cpp

@@ -102,12 +102,23 @@ void nano::unchecked_map::clear ()
 	entries.clear ();
 }
 
-std::size_t nano::unchecked_map::count () const
+size_t nano::unchecked_map::entries_size () const
 {
 	nano::lock_guard<std::recursive_mutex> lock{ entries_mutex };
 	return entries.size ();
 }
 
+size_t nano::unchecked_map::queries_size () const
+{
+	nano::lock_guard<nano::mutex> lock{ mutex };
+	return buffer.size ();
+}
+
+size_t nano::unchecked_map::count () const
+{
+	return entries_size ();
+}
+
 void nano::unchecked_map::trigger (nano::hash_or_account const & dependency)
 {
 	nano::unique_lock<nano::mutex> lock{ mutex };
@@ -166,16 +177,10 @@ void nano::unchecked_map::query_impl (nano::block_hash const & hash)
 	}
 }
 
-std::unique_ptr<nano::container_info_component> nano::unchecked_map::collect_container_info (const std::string & name)
+nano::container_info nano::unchecked_map::container_info () const
 {
-	auto composite = std::make_unique<container_info_composite> (name);
-	{
-		std::lock_guard guard{ entries_mutex };
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "entries", entries.size (), sizeof (decltype (entries)::value_type) }));
-	}
-	{
-		nano::lock_guard<nano::mutex> lock{ mutex };
-		composite->add_component (std::make_unique<container_info_leaf> (container_info{ "queries", buffer.size (), sizeof (decltype (buffer)::value_type) }));
-	}
-	return composite;
+	nano::container_info info;
+	info.put ("entries", entries_size ());
+	info.put ("queries", queries_size ());
+	return info;
 }

nano/node/unchecked_map.hpp

@@ -37,13 +37,18 @@ public:
 	bool exists (nano::unchecked_key const & key) const;
 	void del (nano::unchecked_key const & key);
 	void clear ();
-	std::size_t count () const;
 
 	/**
 	 * Trigger requested dependencies
 	 */
 	void trigger (nano::hash_or_account const & dependency);
 
+	size_t count () const; // Same as `entries_size ()`
+	size_t entries_size () const;
+	size_t queries_size () const;
+
+	nano::container_info container_info () const;
+
 public: // Events
 	nano::observer_set<nano::unchecked_info const &> satisfied;
 
@@ -62,7 +67,7 @@ private:
 
 	bool stopped{ false };
 	nano::condition_variable condition;
-	nano::mutex mutex;
+	mutable nano::mutex mutex; // Protects queries
 	std::thread thread;
 
 	unsigned const max_unchecked_blocks;
@@ -88,9 +93,6 @@ private:
 	// clang-format on
 	ordered_unchecked entries;
 
-	mutable std::recursive_mutex entries_mutex;
-
-public: // Container info
-	std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name);
+	mutable std::recursive_mutex entries_mutex; // Protects entries
 };
 }

nano/node/vote_cache.cpp

@@ -272,13 +272,13 @@ void nano::vote_cache::cleanup ()
 	});
 }
 
-std::unique_ptr<nano::container_info_component> nano::vote_cache::collect_container_info (const std::string & name) const
+nano::container_info nano::vote_cache::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "cache", cache.size (), sizeof (ordered_cache::value_type) }));
-	return composite;
+	nano::container_info info;
+	info.put ("cache", cache);
+	return info;
 }
 
 /*

nano/node/vote_cache.hpp

@@ -144,7 +144,6 @@ public:
 	std::size_t size () const;
 	bool empty () const;
 
-public:
 	struct top_entry
 	{
 		nano::block_hash hash;
@@ -159,8 +158,7 @@ public:
 	 */
 	std::deque<top_entry> top (nano::uint128_t const & min_tally);
 
-public: // Container info
-	std::unique_ptr<nano::container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 public:
 	/**

nano/node/vote_generator.cpp

@@ -314,20 +314,13 @@ void nano::vote_generator::run ()
 	}
 }
 
-std::unique_ptr<nano::container_info_component> nano::vote_generator::collect_container_info (std::string const & name) const
+nano::container_info nano::vote_generator::container_info () const
 {
-	std::size_t candidates_count = 0;
-	std::size_t requests_count = 0;
-	{
-		nano::lock_guard<nano::mutex> guard{ mutex };
-		candidates_count = candidates.size ();
-		requests_count = requests.size ();
-	}
-	auto sizeof_candidate_element = sizeof (decltype (candidates)::value_type);
-	auto sizeof_request_element = sizeof (decltype (requests)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "candidates", candidates_count, sizeof_candidate_element }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "requests", requests_count, sizeof_request_element }));
-	composite->add_component (vote_generation_queue.collect_container_info ("vote_generation_queue"));
-	return composite;
-}
+	nano::lock_guard<nano::mutex> guard{ mutex };
+
+	nano::container_info info;
+	info.put ("candidates", candidates.size ());
+	info.put ("requests", requests.size ());
+	info.add ("queue", vote_generation_queue.container_info ());
+	return info;
+}

nano/node/vote_generator.hpp

@@ -5,6 +5,7 @@
 #include <nano/lib/numbers.hpp>
 #include <nano/lib/processing_queue.hpp>
 #include <nano/lib/utility.hpp>
+#include <nano/node/fwd.hpp>
 #include <nano/node/wallet.hpp>
 #include <nano/secure/common.hpp>
 
@@ -21,29 +22,6 @@
 
 namespace mi = boost::multi_index;
 
-namespace nano
-{
-class ledger;
-class local_vote_history;
-class network;
-class node;
-class node_config;
-class stats;
-class vote_processor;
-class vote_spacing;
-class wallets;
-}
-namespace nano::secure
-{
-class transaction;
-class write_transaction;
-class read_transaction;
-}
-namespace nano::transport
-{
-class channel;
-}
-
 namespace nano
 {
 class vote_generator final
@@ -66,7 +44,7 @@ public:
 	void start ();
 	void stop ();
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	using transaction_variant_t = std::variant<nano::secure::read_transaction, nano::secure::write_transaction>;
@@ -96,7 +74,7 @@ private: // Dependencies
 	nano::logger & logger;
 
 private:
-	processing_queue<queue_entry_t> vote_generation_queue;
+	nano::processing_queue<queue_entry_t> vote_generation_queue;
 
 private:
 	const bool is_final;

nano/node/vote_processor.cpp

@@ -218,14 +218,14 @@ bool nano::vote_processor::empty () const
 	return queue.empty ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::vote_processor::collect_container_info (std::string const & name) const
+nano::container_info nano::vote_processor::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "votes", queue.size (), sizeof (decltype (queue)::value_type) }));
-	composite->add_component (queue.collect_container_info ("queue"));
-	return composite;
+	nano::container_info info;
+	info.put ("votes", queue.size ());
+	info.add ("queue", queue.container_info ());
+	return info;
 }
 
 /*
@@ -343,12 +343,13 @@ bool nano::vote_cache_processor::empty () const
 	return size () == 0;
 }
 
-std::unique_ptr<nano::container_info_component> nano::vote_cache_processor::collect_container_info (std::string const & name) const
+nano::container_info nano::vote_cache_processor::container_info () const
 {
 	nano::lock_guard<nano::mutex> guard{ mutex };
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "triggered", triggered.size (), sizeof (decltype (triggered)::value_type) }));
-	return composite;
+
+	nano::container_info info;
+	info.put ("triggered", triggered.size ());
+	return info;
 }
 
 /*

nano/node/vote_processor.hpp

@@ -52,7 +52,7 @@ public:
 	std::size_t size () const;
 	bool empty () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 	std::atomic<uint64_t> total_processed{ 0 };
 
@@ -98,7 +98,7 @@ public:
 	std::size_t size () const;
 	bool empty () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private:
 	void run ();

nano/node/vote_router.cpp

@@ -175,15 +175,6 @@ void nano::vote_router::stop ()
 	}
 }
 
-std::unique_ptr<nano::container_info_component> nano::vote_router::collect_container_info (std::string const & name) const
-{
-	std::shared_lock lock{ mutex };
-
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "elections", elections.size (), sizeof (decltype (elections)::value_type) }));
-	return composite;
-}
-
 void nano::vote_router::run ()
 {
 	std::unique_lock lock{ mutex };
@@ -193,3 +184,12 @@ void nano::vote_router::run ()
 		condition.wait_for (lock, 15s, [&] () { return stopped; });
 	}
 }
+
+nano::container_info nano::vote_router::container_info () const
+{
+	std::shared_lock lock{ mutex };
+
+	nano::container_info info;
+	info.put ("elections", elections);
+	return info;
+}

nano/node/vote_router.hpp

@@ -1,21 +1,13 @@
 #pragma once
 
 #include <nano/lib/numbers.hpp>
+#include <nano/node/fwd.hpp>
 
 #include <memory>
 #include <shared_mutex>
 #include <thread>
 #include <unordered_map>
 
-namespace nano
-{
-class container_info_component;
-class election;
-class recently_confirmed_cache;
-class vote;
-class vote_cache;
-}
-
 namespace nano
 {
 enum class vote_code
@@ -46,6 +38,7 @@ class vote_router final
 public:
 	vote_router (nano::vote_cache & cache, nano::recently_confirmed_cache & recently_confirmed);
 	~vote_router ();
+
 	// Add a route for 'hash' to 'election'
 	// Existing routes will be replaced
 	// Election must hold the block for the hash being passed in
@@ -68,7 +61,7 @@ public:
 	using vote_processed_event_t = nano::observer_set<std::shared_ptr<nano::vote> const &, nano::vote_source, std::unordered_map<nano::block_hash, nano::vote_code> const &>;
 	vote_processed_event_t vote_processed;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 private: // Dependencies
 	nano::vote_cache & vote_cache;

nano/node/wallet.cpp

@@ -1801,20 +1801,12 @@ bool nano::mdb_wallets_store::init_error () const
 	return error;
 }
 
-std::unique_ptr<nano::container_info_component> nano::collect_container_info (wallets & wallets, std::string const & name)
+nano::container_info nano::wallets::container_info () const
 {
-	std::size_t items_count;
-	std::size_t actions_count;
-	{
-		nano::lock_guard<nano::mutex> guard{ wallets.mutex };
-		items_count = wallets.items.size ();
-		actions_count = wallets.actions.size ();
-	}
+	nano::lock_guard<nano::mutex> guard{ mutex };
 
-	auto sizeof_item_element = sizeof (decltype (wallets.items)::value_type);
-	auto sizeof_actions_element = sizeof (decltype (wallets.actions)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "items", items_count, sizeof_item_element }));
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "actions", actions_count, sizeof_actions_element }));
-	return composite;
+	nano::container_info info;
+	info.put ("items", items.size ());
+	info.put ("actions", actions.size ());
+	return info;
 }

nano/node/wallet.hpp

@@ -222,13 +222,15 @@ public:
 	void ongoing_compute_reps ();
 	void receive_confirmed (nano::block_hash const & hash_a, nano::account const & destination_a);
 	std::unordered_map<nano::wallet_id, std::shared_ptr<nano::wallet>> get_wallets ();
+	nano::container_info container_info () const;
+
 	nano::network_params & network_params;
 	std::function<void (bool)> observer;
 	std::unordered_map<nano::wallet_id, std::shared_ptr<nano::wallet>> items;
 	std::multimap<nano::uint128_t, std::pair<std::shared_ptr<nano::wallet>, std::function<void (nano::wallet &)>>, std::greater<nano::uint128_t>> actions;
 	nano::locked<std::unordered_map<nano::account, nano::root>> delayed_work;
-	nano::mutex mutex;
-	nano::mutex action_mutex;
+	mutable nano::mutex mutex;
+	mutable nano::mutex action_mutex;
 	nano::condition_variable condition;
 	nano::kdf kdf;
 	MDB_dbi handle;
@@ -250,8 +252,6 @@ private:
 	nano::wallet_representatives representatives;
 };
 
-std::unique_ptr<container_info_component> collect_container_info (wallets & wallets, std::string const & name);
-
 class wallets_store
 {
 public:

nano/secure/fwd.hpp

@@ -1,6 +1,14 @@
+#pragma once
+
 namespace nano::secure
 {
 class transaction;
 class write_transaction;
 class read_transaction;
+}
+
+namespace nano
+{
+class account_info;
+class vote;
 }

nano/secure/ledger.cpp

@@ -1514,12 +1514,10 @@ uint64_t nano::ledger::pruned_count () const
 	return cache.pruned_count;
 }
 
-std::unique_ptr<nano::container_info_component> nano::ledger::collect_container_info (std::string const & name) const
+nano::container_info nano::ledger::container_info () const
 {
-	auto count = bootstrap_weights.size ();
-	auto sizeof_element = sizeof (decltype (bootstrap_weights)::value_type);
-	auto composite = std::make_unique<container_info_composite> (name);
-	composite->add_component (std::make_unique<container_info_leaf> (container_info{ "bootstrap_weights", count, sizeof_element }));
-	composite->add_component (cache.rep_weights.collect_container_info ("rep_weights"));
-	return composite;
-}
+	nano::container_info info;
+	info.put ("bootstrap_weights", bootstrap_weights);
+	info.add ("rep_weights", cache.rep_weights.container_info ());
+	return info;
+}

nano/secure/ledger.hpp

@@ -82,7 +82,7 @@ public:
 	uint64_t account_count () const;
 	uint64_t pruned_count () const;
 
-	std::unique_ptr<container_info_component> collect_container_info (std::string const & name) const;
+	nano::container_info container_info () const;
 
 public:
 	static nano::uint128_t const unit;

nano/secure/rep_weights.cpp

@@ -126,16 +126,11 @@ std::size_t nano::rep_weights::size () const
 	return rep_amounts.size ();
 }
 
-std::unique_ptr<nano::container_info_component> nano::rep_weights::collect_container_info (std::string const & name) const
+nano::container_info nano::rep_weights::container_info () const
 {
-	size_t rep_amounts_count;
+	std::shared_lock guard{ mutex };
 
-	{
-		std::shared_lock guard{ mutex };
-		rep_amounts_count = rep_amounts.size ();
-	}
-	auto sizeof_element = sizeof (decltype (rep_amounts)::value_type);
-	auto composite = std::make_unique<nano::container_info_composite> (name);
-	composite->add_component (std::make_unique<nano::container_info_leaf> (container_info{ "rep_amounts", rep_amounts_count, sizeof_element }));
-	return composite;
+	nano::container_info info;
+	info.put ("rep_amounts", rep_amounts);
+	return info;
 }

nano/secure/rep_weights.hpp

@@ -29,7 +29,7 @@ public:
 	/* Only use this method when loading rep weights from the database table */
 	void copy_from (rep_weights & other_a);
 	size_t size () const;
-	std::unique_ptr<container_info_component> collect_container_info (std::string const &) const;
+	nano::container_info container_info () const;
 
 private:
 	mutable std::shared_mutex mutex;