A few missing emojies (#5490)

* A few missing emojies

* P2p message emojis

* Add a bit of colour

* format

* Introduce a couple of spaces

* Some spaces

substrate/bin/node/cli/src/browser.rs

@@ -44,7 +44,7 @@ async fn start_inner(chain_spec: String, log_level: String) -> Result<Client, Bo
 	info!("  version {}", config.full_version());
 	info!("  by Parity Technologies, 2017-2020");
 	info!("📋 Chain specification: {}", config.expect_chain_spec().name());
-	info!("🏷 Node name: {}", config.name);
+	info!("🏷  Node name: {}", config.name);
 	info!("👤 Roles: {:?}", config.roles);
 
 	// Create the service. This is the most heavy initialization step.

substrate/client/cli/src/commands/runcmd.rs

@@ -462,7 +462,7 @@ impl RunCmd {
 		info!("  version {}", config.full_version());
 		info!("  by {}, {}-{}", version.author, version.copyright_start_year, Local::today().year());
 		info!("📋 Chain specification: {}", config.expect_chain_spec().name());
-		info!("🏷 Node name: {}", config.name);
+		info!("🏷  Node name: {}", config.name);
 		info!("👤 Roles: {}", config.display_role());
 
 		match config.roles {

substrate/client/informant/src/display.rs

@@ -76,16 +76,16 @@ impl<B: BlockT> InformantDisplay<B> {
 		if self.format == OutputFormat::Coloured {
 			info!(
 				target: "substrate",
-				"{}{} ({} peers), best: #{} ({}), finalized #{} ({}), ⬇ {} ⬆ {}",
+				"{}{} ({} peers), best: #{} ({}), finalized #{} ({}), {} {}",
 				Colour::White.bold().paint(&status),
 				target,
 				Colour::White.bold().paint(format!("{}", num_connected_peers)),
-				Colour::White.paint(format!("{}", best_number)),
+				Colour::White.bold().paint(format!("{}", best_number)),
 				best_hash,
-				Colour::White.paint(format!("{}", finalized_number)),
+				Colour::White.bold().paint(format!("{}", finalized_number)),
 				info.chain.finalized_hash,
-				TransferRateFormat(net_status.average_download_per_sec),
-				TransferRateFormat(net_status.average_upload_per_sec),
+				Colour::Green.paint(format!("⬇ {}", TransferRateFormat(net_status.average_download_per_sec))),
+				Colour::Red.paint(format!("⬆ {}", TransferRateFormat(net_status.average_upload_per_sec))),
 			);
 		} else {
 			info!(

substrate/client/informant/src/lib.rs

@@ -16,6 +16,7 @@
 
 //! Console informant. Prints sync progress and block events. Runs on the calling thread.
 
+use ansi_term::Colour;
 use sc_client_api::BlockchainEvents;
 use futures::prelude::*;
 use log::{info, warn, trace};
@@ -79,10 +80,10 @@ pub fn build(service: &impl AbstractService, format: OutputFormat) -> impl futur
 
 				match maybe_ancestor {
 					Ok(ref ancestor) if ancestor.hash != *last_hash => info!(
-						"♻️ Reorg from #{},{} to #{},{}, common ancestor #{},{}",
-						last_num, last_hash,
-						n.header.number(), n.hash,
-						ancestor.number, ancestor.hash,
+						"♻️  Reorg on #{},{} to #{},{}, common ancestor #{},{}",
+						Colour::Red.bold().paint(format!("{}", last_num)), last_hash,
+						Colour::Green.bold().paint(format!("{}", n.header.number())), n.hash,
+						Colour::White.bold().paint(format!("{}", ancestor.number)), ancestor.hash,
 					),
 					Ok(_) => {},
 					Err(e) => warn!("Error computing tree route: {}", e),
@@ -94,7 +95,7 @@ pub fn build(service: &impl AbstractService, format: OutputFormat) -> impl futur
 			last_best = Some((n.header.number().clone(), n.hash.clone()));
 		}
 
-		info!(target: "substrate", "✨ Imported #{} ({})", n.header.number(), n.hash);
+		info!(target: "substrate", "✨ Imported #{} ({})", Colour::White.bold().paint(format!("{}", n.header.number())), n.hash);
 		future::ready(())
 	});
 

substrate/client/network/src/protocol/generic_proto/handler/notif_out.rs

@@ -244,8 +244,8 @@ impl ProtocolsHandler for NotifsOutHandler {
 
 			// Any other situation should never happen.
 			State::Disabled | State::Refused | State::Open { .. } | State::DisabledOpen(_) =>
-				error!("State mismatch in notifications handler: substream already open"),
-			State::Poisoned => error!("Notifications handler in a poisoned state"),
+				error!("☎️ State mismatch in notifications handler: substream already open"),
+			State::Poisoned => error!("☎️ Notifications handler in a poisoned state"),
 		}
 	}
 
@@ -270,7 +270,7 @@ impl ProtocolsHandler for NotifsOutHandler {
 						if sub.close().now_or_never().is_none() {
 							log::warn!(
 								target: "sub-libp2p",
-								"Improperly closed outbound notifications substream"
+								"📞 Improperly closed outbound notifications substream"
 							);
 						}
 
@@ -282,19 +282,19 @@ impl ProtocolsHandler for NotifsOutHandler {
 						self.state = State::Opening { initial_message };
 					},
 					State::Opening { .. } | State::Refused | State::Open { .. } =>
-						error!("Tried to enable notifications handler that was already enabled"),
-					State::Poisoned => error!("Notifications handler in a poisoned state"),
+						error!("☎️ Tried to enable notifications handler that was already enabled"),
+					State::Poisoned => error!("☎️ Notifications handler in a poisoned state"),
 				}
 			}
 
 			NotifsOutHandlerIn::Disable => {
 				match mem::replace(&mut self.state, State::Poisoned) {
 					State::Disabled | State::DisabledOpen(_) | State::DisabledOpening =>
-						error!("Tried to disable notifications handler that was already disabled"),
+						error!("☎️ Tried to disable notifications handler that was already disabled"),
 					State::Opening { .. } => self.state = State::DisabledOpening,
 					State::Refused => self.state = State::Disabled,
 					State::Open { substream, .. } => self.state = State::DisabledOpen(substream),
-					State::Poisoned => error!("Notifications handler in a poisoned state"),
+					State::Poisoned => error!("☎️ Notifications handler in a poisoned state"),
 				}
 			}
 
@@ -304,14 +304,14 @@ impl ProtocolsHandler for NotifsOutHandler {
 					} else {
 						log::warn!(
 							target: "sub-libp2p",
-							"Failed to push message to queue, dropped it"
+							"📞 Failed to push message to queue, dropped it"
 						);
 					}
 				} else {
 					// This is an API misuse.
 					log::warn!(
 						target: "sub-libp2p",
-						"Tried to send a notification on a disabled handler"
+						"📞 Tried to send a notification on a disabled handler"
 					);
 				},
 		}
@@ -321,14 +321,14 @@ impl ProtocolsHandler for NotifsOutHandler {
 		match mem::replace(&mut self.state, State::Poisoned) {
 			State::Disabled => {},
 			State::DisabledOpen(_) | State::Refused | State::Open { .. } =>
-				error!("State mismatch in NotificationsOut"),
+				error!("☎️ State mismatch in NotificationsOut"),
 			State::Opening { .. } => {
 				self.state = State::Refused;
 				let ev = NotifsOutHandlerOut::Refused;
 				self.events_queue.push(ProtocolsHandlerEvent::Custom(ev));
 			},
 			State::DisabledOpening => self.state = State::Disabled,
-			State::Poisoned => error!("Notifications handler in a poisoned state"),
+			State::Poisoned => error!("☎️ Notifications handler in a poisoned state"),
 		}
 	}
 

substrate/client/network/src/service.rs

@@ -226,7 +226,7 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkWorker<B, H> {
 		let local_identity = params.network_config.node_key.clone().into_keypair()?;
 		let local_public = local_identity.public();
 		let local_peer_id = local_public.clone().into_peer_id();
-		info!(target: "sub-libp2p", "Local node identity is: {}", local_peer_id.to_base58());
+		info!(target: "sub-libp2p", "🏷  Local node identity is: {}", local_peer_id.to_base58());
 
 		let checker = params.on_demand.as_ref()
 			.map(|od| od.checker().clone())

substrate/client/telemetry/src/worker/node.rs

@@ -116,7 +116,7 @@ where TTrans: Clone + Unpin, TTrans::Dial: Unpin,
 				pending.push_back(payload.into());
 				Ok(())
 			} else {
-				warn!(target: "telemetry", "Rejected log entry because queue is full for {:?}",
+				warn!(target: "telemetry", "⚠️ Rejected log entry because queue is full for {:?}",
 					self.addr);
 				Err(())
 			}
@@ -137,7 +137,7 @@ where TTrans: Clone + Unpin, TTrans::Dial: Unpin,
 							break NodeSocket::Connected(conn)
 						},
 						Poll::Ready(Err(err)) => {
-							warn!(target: "telemetry", "Disconnected from {}: {:?}", self.addr, err);
+							warn!(target: "telemetry", "⚠️ Disconnected from {}: {:?}", self.addr, err);
 							let timeout = gen_rand_reconnect_delay();
 							self.socket = NodeSocket::WaitingReconnect(timeout);
 							return Poll::Ready(NodeEvent::Disconnected(err))
@@ -146,7 +146,7 @@ where TTrans: Clone + Unpin, TTrans::Dial: Unpin,
 				}
 				NodeSocket::Dialing(mut s) => match Future::poll(Pin::new(&mut s), cx) {
 					Poll::Ready(Ok(sink)) => {
-						debug!(target: "telemetry", "Connected to {}", self.addr);
+						debug!(target: "telemetry", "✅ Connected to {}", self.addr);
 						let conn = NodeSocketConnected {
 							sink,
 							pending: VecDeque::new(),
@@ -158,7 +158,7 @@ where TTrans: Clone + Unpin, TTrans::Dial: Unpin,
 					},
 					Poll::Pending => break NodeSocket::Dialing(s),
 					Poll::Ready(Err(err)) => {
-						warn!(target: "telemetry", "Error while dialing {}: {:?}", self.addr, err);
+						warn!(target: "telemetry", "❌ Error while dialing {}: {:?}", self.addr, err);
 						let timeout = gen_rand_reconnect_delay();
 						socket = NodeSocket::WaitingReconnect(timeout);
 					}
@@ -169,7 +169,7 @@ where TTrans: Clone + Unpin, TTrans::Dial: Unpin,
 						socket = NodeSocket::Dialing(d);
 					}
 					Err(err) => {
-						warn!(target: "telemetry", "Error while dialing {}: {:?}", self.addr, err);
+						warn!(target: "telemetry", "❌ Error while dialing {}: {:?}", self.addr, err);
 						let timeout = gen_rand_reconnect_delay();
 						socket = NodeSocket::WaitingReconnect(timeout);
 					}
@@ -181,7 +181,7 @@ where TTrans: Clone + Unpin, TTrans::Dial: Unpin,
 						break NodeSocket::WaitingReconnect(s)
 					}
 				NodeSocket::Poisoned => {
-					error!(target: "telemetry", "Poisoned connection with {}", self.addr);
+					error!(target: "telemetry", "‼️ Poisoned connection with {}", self.addr);
 					break NodeSocket::Poisoned
 				}
 			}

substrate/utils/prometheus/src/lib.rs

@@ -120,7 +120,7 @@ mod known_os {
 			.await
 			.map_err(|_| Error::PortInUse(prometheus_addr))?;
 
-		log::info!("Prometheus server started at {}", prometheus_addr);
+		log::info!("〽️ Prometheus server started at {}", prometheus_addr);
 
 		let service = make_service_fn(move |_| {
 			let registry = registry.clone();