dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Remove unnecessary fmt::streamed

Browse source
This commit is contained in:
Piotr Wójcik 2025-01-21 18:25:32 +01:00
commit c0a278b231
8 changed files with 39 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/node/network.cpp
View file

@ -357,12 +357,12 @@ bool nano::network::merge_peer (nano::endpoint const & peer)
if (track_reachout (peer))
{
node.stats.inc (nano::stat::type::network, nano::stat::detail::merge_peer);
node.logger.debug (nano::log::type::network, "Initiating peer merge: {}", fmt::streamed (peer));
node.logger.debug (nano::log::type::network, "Initiating peer merge: {}", peer);
bool started = tcp_channels.start_tcp (peer);
if (!started)
{
node.stats.inc (nano::stat::type::tcp, nano::stat::detail::merge_peer_failed);
node.logger.debug (nano::log::type::network, "Peer merge failed: {}", fmt::streamed (peer));
node.logger.debug (nano::log::type::network, "Peer merge failed: {}", peer);
}
return started;
}

4
nano/node/online_reps.cpp
View file

@ -32,7 +32,7 @@ void nano::online_reps::start ()
nano::lock_guard<nano::mutex> lock{ mutex };
cached_trended = trended_l;
logger.info (nano::log::type::online_reps, "Initial trended weight: {}", fmt::streamed (cached_trended));
logger.info (nano::log::type::online_reps, "Initial trended weight: {}", cached_trended);
}
thread = std::thread ([this] () {
@ -125,7 +125,7 @@ void nano::online_reps::sample ()
nano::lock_guard<nano::mutex> lock{ mutex };
cached_trended = trended_l;
}
logger.info (nano::log::type::online_reps, "Updated trended weight: {}", fmt::streamed (trended_l));
logger.info (nano::log::type::online_reps, "Updated trended weight: {}", trended_l);
}
nano::uint128_t nano::online_reps::calculate_online () const

4
nano/node/peer_history.cpp
View file

@ -92,7 +92,7 @@ void nano::peer_history::run_one ()
if (!exists)
{
stats.inc (nano::stat::type::peer_history, nano::stat::detail::inserted);
logger.debug (nano::log::type::peer_history, "Saved new peer: {}", fmt::streamed (endpoint));
logger.debug (nano::log::type::peer_history, "Saved new peer: {}", endpoint);
}
else
{
@ -116,7 +116,7 @@ void nano::peer_history::run_one ()
stats.inc (nano::stat::type::peer_history, nano::stat::detail::erased);
logger.debug (nano::log::type::peer_history, "Erased peer: {} (not seen for {}s)",
fmt::streamed (endpoint.endpoint ()),
endpoint.endpoint (),
nano::log::seconds_delta (timestamp));
}
}

8
nano/node/transport/tcp_channels.cpp
View file

@ -56,7 +56,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint,
if (node.network.not_a_peer (nano::transport::map_tcp_to_endpoint (endpoint), node.config.allow_local_peers))
{
node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::not_a_peer);
node.logger.debug (nano::log::type::tcp_channels, "Rejected invalid endpoint channel: {}", fmt::streamed (endpoint));
node.logger.debug (nano::log::type::tcp_channels, "Rejected invalid endpoint channel: {}", endpoint);
return false; // Reject
}
@ -76,7 +76,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint,
if (has_duplicate)
{
node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::channel_duplicate);
node.logger.debug (nano::log::type::tcp_channels, "Rejected duplicate channel: {} ({})", fmt::streamed (endpoint), node_id.to_node_id ());
node.logger.debug (nano::log::type::tcp_channels, "Rejected duplicate channel: {} ({})", endpoint, node_id.to_node_id ());
return false; // Reject
}
@ -100,7 +100,7 @@ std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::cre
if (!check (endpoint, node_id))
{
node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_rejected);
node.logger.debug (nano::log::type::tcp_channels, "Rejected channel: {} ({})", fmt::streamed (endpoint), node_id.to_node_id ());
node.logger.debug (nano::log::type::tcp_channels, "Rejected channel: {} ({})", endpoint, node_id.to_node_id ());
// Rejection reason should be logged earlier
return nullptr;
@ -108,7 +108,7 @@ std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::cre
node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_accepted);
node.logger.debug (nano::log::type::tcp_channels, "Accepted channel: {} ({}) ({})",
fmt::streamed (socket->remote_endpoint ()),
socket->remote_endpoint (),
to_string (socket->endpoint_type ()),
node_id.to_node_id ());

10
nano/node/transport/tcp_listener.cpp
View file

@ -58,7 +58,7 @@ void nano::transport::tcp_listener::start ()
local = acceptor.local_endpoint ();
}
logger.debug (nano::log::type::tcp_listener, "Listening for incoming connections on: {}", fmt::streamed (acceptor.local_endpoint ()));
logger.debug (nano::log::type::tcp_listener, "Listening for incoming connections on: {}", acceptor.local_endpoint ());
}
catch (boost::system::system_error const & ex)
{
@ -286,7 +286,7 @@ auto nano::transport::tcp_listener::connect_impl (asio::ip::tcp::endpoint endpoi
if (result.result == accept_result::accepted)
{
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_success, nano::stat::dir::out);
logger.debug (nano::log::type::tcp_listener, "Successfully connected to: {}", fmt::streamed (endpoint));
logger.debug (nano::log::type::tcp_listener, "Successfully connected to: {}", endpoint);
release_assert (result.server);
result.server->initiate_handshake ();
@ -300,7 +300,7 @@ auto nano::transport::tcp_listener::connect_impl (asio::ip::tcp::endpoint endpoi
catch (boost::system::system_error const & ex)
{
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_error, nano::stat::dir::out);
logger.log (nano::log::level::debug, nano::log::type::tcp_listener, "Error connecting to: {} ({})", fmt::streamed (endpoint), ex.what ());
logger.log (nano::log::level::debug, nano::log::type::tcp_listener, "Error connecting to: {} ({})", endpoint, ex.what ());
}
}
@ -387,7 +387,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
if (auto result = check_limits (remote_endpoint.address (), type); result != accept_result::accepted)
{
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_rejected, to_stat_dir (type));
logger.debug (nano::log::type::tcp_listener, "Rejected connection from: {} ({})", fmt::streamed (remote_endpoint), to_string (type));
logger.debug (nano::log::type::tcp_listener, "Rejected connection from: {} ({})", remote_endpoint, to_string (type));
// Rejection reason should be logged earlier
try
@ -406,7 +406,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
}
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_success, to_stat_dir (type));
logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", fmt::streamed (remote_endpoint), to_string (type));
logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", remote_endpoint, to_string (type));
auto socket = std::make_shared<nano::transport::tcp_socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type));
auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true);

38
nano/node/transport/tcp_server.cpp
View file

@ -33,7 +33,7 @@ nano::transport::tcp_server::~tcp_server ()
return;
}
node->logger.debug (nano::log::type::tcp_server, "Exiting server: {}", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Exiting server: {}", remote_endpoint);
stop ();
}
@ -53,7 +53,7 @@ void nano::transport::tcp_server::start ()
return;
}
node->logger.debug (nano::log::type::tcp_server, "Starting server: {}", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Starting server: {}", remote_endpoint);
receive_message ();
}
@ -86,7 +86,7 @@ void nano::transport::tcp_server::receive_message ()
node->logger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})",
ec.message (),
to_string (this_l->message_deserializer->status),
fmt::streamed (this_l->remote_endpoint));
this_l->remote_endpoint);
this_l->stop ();
}
@ -134,7 +134,7 @@ void nano::transport::tcp_server::received_message (std::unique_ptr<nano::messag
{
node->logger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})",
to_string (message_deserializer->status),
fmt::streamed (remote_endpoint));
remote_endpoint);
}
break;
}
@ -193,7 +193,7 @@ auto nano::transport::tcp_server::process_message (std::unique_ptr<nano::message
case handshake_status::abort:
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_abort);
node->logger.debug (nano::log::type::tcp_server, "Aborting handshake: {} ({})", to_string (message->type ()), fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Aborting handshake: {} ({})", to_string (message->type ()), remote_endpoint);
return process_result::abort;
}
@ -212,7 +212,7 @@ auto nano::transport::tcp_server::process_message (std::unique_ptr<nano::message
if (!success)
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Error switching to bootstrap mode: {} ({})", to_string (message->type ()), fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Error switching to bootstrap mode: {} ({})", to_string (message->type ()), remote_endpoint);
return process_result::abort; // Switch failed, abort
}
@ -276,21 +276,21 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
if (node->flags.disable_tcp_realtime)
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime mode ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime mode ({})", remote_endpoint);
return handshake_status::abort;
}
if (!message.query && !message.response)
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Invalid handshake message received ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Invalid handshake message received ({})", remote_endpoint);
return handshake_status::abort;
}
if (message.query && handshake_received) // Second handshake message should be a response only
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", remote_endpoint);
return handshake_status::abort;
}
@ -300,7 +300,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::node_id_handshake, nano::stat::dir::in);
node->logger.debug (nano::log::type::tcp_server, "Handshake message received: {} ({})",
message.query ? (message.response ? "query + response" : "query") : (message.response ? "response" : "none"),
fmt::streamed (remote_endpoint));
remote_endpoint);
if (message.query)
{
@ -320,7 +320,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
else
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Error switching to realtime mode ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Error switching to realtime mode ({})", remote_endpoint);
return handshake_status::abort;
}
@ -328,7 +328,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
else
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_response_invalid);
node->logger.debug (nano::log::type::tcp_server, "Invalid handshake response received ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Invalid handshake response received ({})", remote_endpoint);
return handshake_status::abort;
}
@ -348,7 +348,7 @@ void nano::transport::tcp_server::initiate_handshake ()
auto query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint));
nano::node_id_handshake message{ node->network_params.network, query };
node->logger.debug (nano::log::type::tcp_server, "Initiating handshake query ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Initiating handshake query ({})", remote_endpoint);
auto shared_const_buffer = message.to_shared_const_buffer ();
socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) {
@ -360,7 +360,7 @@ void nano::transport::tcp_server::initiate_handshake ()
if (ec)
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error);
node->logger.debug (nano::log::type::tcp_server, "Error sending handshake query: {} ({})", ec.message (), fmt::streamed (this_l->remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Error sending handshake query: {} ({})", ec.message (), this_l->remote_endpoint);
// Stop invalid handshake
this_l->stop ();
@ -385,7 +385,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha
auto own_query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint));
nano::node_id_handshake handshake_response{ node->network_params.network, own_query, response };
node->logger.debug (nano::log::type::tcp_server, "Responding to handshake ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Responding to handshake ({})", remote_endpoint);
auto shared_const_buffer = handshake_response.to_shared_const_buffer ();
socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) {
@ -397,7 +397,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha
if (ec)
{
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error);
node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), fmt::streamed (this_l->remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), this_l->remote_endpoint);
// Stop invalid handshake
this_l->stop ();
@ -551,7 +551,7 @@ void nano::transport::tcp_server::timeout ()
}
if (socket->has_timed_out ())
{
node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", remote_endpoint);
socket->close ();
}
@ -600,7 +600,7 @@ bool nano::transport::tcp_server::to_bootstrap_connection ()
socket->type_set (nano::transport::socket_type::bootstrap);
node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", remote_endpoint);
return true;
}
@ -630,7 +630,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const &
socket->type_set (nano::transport::socket_type::realtime);
node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", fmt::streamed (remote_endpoint));
node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", remote_endpoint);
return true;
}

11
nano/node/transport/tcp_socket.cpp
View file

@ -83,10 +83,7 @@ void nano::transport::tcp_socket::async_connect (nano::tcp_endpoint const & endp
boost::system::error_code ec;
this_l->local = this_l->raw_socket.local_endpoint (ec);
}
node_l->logger.debug (nano::log::type::tcp_socket, "Successfully connected to: {}, local: {}",
fmt::streamed (this_l->remote),
fmt::streamed (this_l->local));
node_l->logger.debug (nano::log::type::tcp_socket, "Successfully connected to: {}, local: {}", this_l->remote, this_l->local);
}
callback (ec);
}));
@ -318,7 +315,7 @@ void nano::transport::tcp_socket::ongoing_checkup ()
if (condition_to_disconnect)
{
// TODO: Stats
node_l->logger.debug (nano::log::type::tcp_socket, "Socket timeout, closing: {}", fmt::streamed (this_l->remote));
node_l->logger.debug (nano::log::type::tcp_socket, "Socket timeout, closing: {}", this_l->remote);
this_l->timed_out = true;
this_l->close ();
}
@ -395,13 +392,13 @@ void nano::transport::tcp_socket::close_internal ()
{
node_l->stats.inc (nano::stat::type::socket, nano::stat::detail::error_socket_close);
node_l->logger.error (nano::log::type::tcp_socket, "Failed to close socket gracefully: {} ({})",
fmt::streamed (remote),
remote,
ec.message ());
}
else
{
// TODO: Stats
node_l->logger.debug (nano::log::type::tcp_socket, "Closed socket: {}", fmt::streamed (remote));
node_l->logger.debug (nano::log::type::tcp_socket, "Closed socket: {}", remote);
}
}

2
nano/rpc/rpc.cpp
View file

@ -45,7 +45,7 @@ void nano::rpc::start ()
logger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ());
throw std::runtime_error (ec.message ());
}
logger.info (nano::log::type::rpc, "RPC listening address: {}", fmt::streamed (acceptor.local_endpoint ()));
logger.info (nano::log::type::rpc, "RPC listening address: {}", acceptor.local_endpoint ());
acceptor.listen ();
accept ();
}