cleanups.

polkadot/cli/src/informant.rs

@@ -46,14 +46,15 @@ pub fn start<B, E>(service: &Service<B, E>, handle: reactor::Handle)
 
 		if let Ok(best_block) = client.best_block_header() {
 			let hash = best_block.hash();
+			let num_peers = sync_status.num_peers;
 			let status = match (sync_status.sync.state, sync_status.sync.best_seen_block) {
 				(SyncState::Idle, _) => "Idle".into(),
 				(SyncState::Downloading, None) => "Syncing".into(),
 				(SyncState::Downloading, Some(n)) => format!("Syncing, target=#{}", n),
 			};
 			let txpool_status = txpool.light_status();
 			info!(target: "polkadot", "{} ({} peers), best: #{} ({})", status, sync_status.num_peers, best_block.number, hash);
-			telemetry!("system.interval"; "status" => status, "peers" => sync_status.num_peers, "height" => best_block.number, "best" => %hash, "txcount" => txpool_status.transaction_count);
+			telemetry!("system.interval"; "status" => status, "peers" => num_peers, "height" => best_block.number, "best" => %hash, "txcount" => txpool_status.transaction_count);
 		} else {
 			warn!("Error getting best block information");
 		}

polkadot/cli/src/lib.rs

@@ -61,12 +61,12 @@ use std::io;
 use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 use polkadot_primitives::Block;
-use polkadot_telemetry::{TelemetryWriter, TelemetryConfig};
+use polkadot_telemetry::{init_telemetry, TelemetryConfig};
 
 use futures::sync::mpsc;
 use futures::{Sink, Future, Stream};
 use tokio_core::reactor;
-use service::ChainSpec;
+use service::{OptionChainSpec, ChainSpec};
 
 const DEFAULT_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io:443";
 
@@ -131,22 +131,24 @@ pub fn run<I, T>(args: I) -> error::Result<()> where
 		info!("Node name: {}", config.name);
 	}
 
-	if matches.is_present("telemetry") || matches.value_of("telemetry-url").is_some() {
+	let _guard = if matches.is_present("telemetry") || matches.value_of("telemetry-url").is_some() {
 		let name = config.name.clone();
 		let chain = config.chain_spec.clone();
-		TelemetryWriter::enable(TelemetryConfig {
+		Some(init_telemetry(TelemetryConfig {
 			url: matches.value_of("telemetry-url").unwrap_or(DEFAULT_TELEMETRY_URL).into(),
 			on_connect: Box::new(move || {
 				telemetry!("system.connected";
 					"name" => name.clone(),
 					"implementation" => "parity-polkadot",
 					"version" => crate_version!(),
 					"config" => "",
-					"chain" => ?chain
+					"chain" => <&'static str>::from(chain)
 				);
 			}),
-		})
-	}
+		}))
+	} else {
+		None
+	};
 
 	let base_path = matches.value_of("base-path")
 		.map(|x| Path::new(x).to_owned())
@@ -175,17 +177,11 @@ pub fn run<I, T>(args: I) -> error::Result<()> where
 	}
 
 	match matches.value_of("chain") {
-		Some("dev") => config.chain_spec = ChainSpec::Development,
-		Some("local") => config.chain_spec = ChainSpec::LocalTestnet,
-		Some("poc-2") => config.chain_spec = ChainSpec::PoC2Testnet,
 		None => (),
-		Some(unknown) => panic!("Invalid chain name: {}", unknown),
+		Some(n) => config.chain_spec = OptionChainSpec::from(n).inner()
+			.unwrap_or_else(|| panic!("Invalid chain name: {}", n)),
 	}
-	info!("Chain specification: {}", match config.chain_spec {
-		ChainSpec::Development => "Development",
-		ChainSpec::LocalTestnet => "Local Testnet",
-		ChainSpec::PoC2Testnet => "PoC-2 Testnet",
-	});
+	info!("Chain specification: {}", config.chain_spec);
 
 	config.roles = role;
 	{

polkadot/service/src/config.rs

@@ -32,6 +32,47 @@ pub enum ChainSpec {
 	PoC2Testnet,
 }
 
+/// Synonym for Option<ChainSpec> because we cannot `impl From<..> for Option<ChainSpec>`
+pub struct OptionChainSpec(Option<ChainSpec>);
+
+impl OptionChainSpec {
+	/// Return the inner part.
+	pub fn inner(self) -> Option<ChainSpec> {
+		self.0
+	}
+}
+
+impl<'a> From<&'a str> for OptionChainSpec {
+	fn from(s: &'a str) -> Self {
+		OptionChainSpec(Some(match s {
+			"dev" => ChainSpec::Development,
+			"local" => ChainSpec::LocalTestnet,
+			"poc-2" => ChainSpec::PoC2Testnet,
+			_ => return OptionChainSpec(None),
+		}))
+	}
+}
+
+impl From<ChainSpec> for &'static str {
+	fn from(s: ChainSpec) -> &'static str {
+		match s {
+			ChainSpec::Development => "dev",
+			ChainSpec::LocalTestnet => "local",
+			ChainSpec::PoC2Testnet => "poc-2",
+		}
+	}
+}
+
+impl ::std::fmt::Display for ChainSpec {
+	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+		write!(f, "{}", match *self {
+			ChainSpec::Development => "Development",
+			ChainSpec::LocalTestnet => "Local Testnet",
+			ChainSpec::PoC2Testnet => "PoC-2 Testnet",
+		})
+	}
+}
+
 /// Service configuration.
 #[derive(Clone)]
 pub struct Configuration {

polkadot/service/src/lib.rs

@@ -75,7 +75,7 @@ use network::ManageNetwork;
 use exit_future::Signal;
 
 pub use self::error::{ErrorKind, Error};
-pub use config::{Configuration, Role, ChainSpec};
+pub use config::{Configuration, Role, OptionChainSpec, ChainSpec};
 
 type CodeExecutor = NativeExecutor<LocalDispatch>;
 

polkadot/telemetry/src/lib.rs

@@ -15,55 +15,74 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Telemtetry utils.
+//! 
+//! `telemetry` macro be used from whereever in the Polkadot codebase
+//! in order to send real-time logging information to the telemetry
+//! server (if there is one). We use the async drain adapter of `slog`
+//! so that the logging thread doesn't get held up at all.
 
 extern crate parking_lot;
 extern crate websocket as ws;
 extern crate slog_async;
 extern crate slog_json;
-#[macro_use]
-extern crate lazy_static;
-#[macro_use]
+#[macro_use(o, kv)]
 extern crate slog;
+extern crate slog_scope;
 
 use std::io;
 use parking_lot::Mutex;
 use slog::Drain;
+pub use slog_scope::with_logger;
 
+/// Configuration for telemetry.
 pub struct TelemetryConfig {
+	/// URL of the telemetry WS server.
 	pub url: String,
+	/// What do do when we connect to the server.
 	pub on_connect: Box<Fn() + Send + 'static>,
 }
 
-lazy_static!{
-	static ref TELEMETRY_CONFIG: Mutex<Option<TelemetryConfig>> = Mutex::new(None);
+/// Initialise telemetry.
+pub fn init_telemetry(config: TelemetryConfig) -> slog_scope::GlobalLoggerGuard {
+	let log = slog::Logger::root(
+		slog_async::Async::new(
+			slog_json::Json::default(
+				TelemetryWriter::from_config(config)
+			).fuse()
+		).build().fuse(), o!()
+	);
+	slog_scope::set_global_logger(log)
 }
 
-pub struct TelemetryWriter {
+/// Exactly equivalent to `slog_scope::info`, provided as a convenience.
+#[macro_export]
+macro_rules! telemetry {
+	( $($t:tt)* ) => { $crate::with_logger(|l| slog_info!(l, $($t)* )) }
+}
+
+struct TelemetryWriter {
 	buffer: Vec<u8>,
 	out: Mutex<Option<ws::sync::Client<Box<ws::stream::sync::NetworkStream + Send>>>>,
+	config: TelemetryConfig,
 }
 
 impl TelemetryWriter {
-	fn new() -> Self {
-		TelemetryWriter { buffer: vec![], out: Mutex::new(None) }
-	}
-
-	pub fn disable() {
-		*TELEMETRY_CONFIG.lock() = None;
-	}
-
-	pub fn enable(config: TelemetryConfig) {
-		*TELEMETRY_CONFIG.lock() = Some(config);
+	fn from_config(config: TelemetryConfig) -> Self {
+		TelemetryWriter {
+			buffer: vec![],
+			out: Mutex::new(
+				ws::ClientBuilder::new(&config.url).ok().and_then(|mut x| x.connect(None).ok())
+			),
+			config: config,
+		}
 	}
 
 	fn ensure_connected(&self) {
 		let mut client = self.out.lock();
 		if client.is_none() {
-			if let Some(ref config) = *TELEMETRY_CONFIG.lock() {
-				*client = ws::ClientBuilder::new(&config.url).ok().and_then(|mut x| x.connect(None).ok());
-				drop(client);
-				(config.on_connect)();
-			}
+			*client = ws::ClientBuilder::new(&self.config.url).ok().and_then(|mut x| x.connect(None).ok());
+			drop(client);
+			(self.config.on_connect)();
 		}
 	}
 }
@@ -77,7 +96,7 @@ impl io::Write for TelemetryWriter {
 		}
 		Ok(msg.len())
 	}
-	
+
 	fn flush(&mut self) -> io::Result<()> {
 		self.ensure_connected();
 		if if let Some(ref mut socket) = *self.out.lock() {
@@ -91,12 +110,3 @@ impl io::Write for TelemetryWriter {
 		Ok(())
 	}
 }
-
-lazy_static!{
-	pub static ref SLOG_TELEMETRY: slog::Logger = slog::Logger::root(slog_async::Async::new(slog_json::Json::default(TelemetryWriter::new()).fuse()).build().fuse(), o!());
-}
-
-#[macro_export]
-macro_rules! telemetry {
-	( $($t:tt)* ) => { slog_info!($crate::SLOG_TELEMETRY, $($t)*) }
-}