RPC logging parameters refactoring

Author: Mariusz Reichert

src/config.rs

@@ -40,7 +40,7 @@ pub struct Config {
     pub utxos_limit: usize,
     pub electrum_txs_limit: usize,
     pub electrum_banner: String,
-    pub rpc_logging_modes: Option<RpcLoggingModes>,
+    pub rpc_logging: RpcLogging,
     pub zmq_addr: Option<SocketAddr>,
 
     /// Enable compaction during initial sync
@@ -74,10 +74,6 @@ fn str_to_socketaddr(address: &str, what: &str) -> SocketAddr {
 impl Config {
     pub fn from_args() -> Config {
         let network_help = format!("Select network type ({})", Network::names().join(", "));
-        let rpc_logging_help = format!(
-            "Select possible RPC logging options: {}",
-            RpcLoggingModes::get_modes().join(", ")
-        );
 
         let args = App::new("Electrum Rust Server")
             .version(crate_version!())
@@ -201,12 +197,20 @@ impl Config {
                     .help("Welcome banner for the Electrum server, shown in the console to clients.")
                     .takes_value(true)
             ).arg(
-                Arg::with_name("rpc_logging_modes")
-                    .long("electrum-rpc-logging")
-                    .help(&rpc_logging_help)
-                    .takes_value(true)
-                    .multiple(true)
-                    .possible_values(&RpcLoggingModes::get_modes()),
+                Arg::with_name("enable_json_rpc_logging")
+                    .long("enable-json-rpc-logging")
+                    .help("turns on rpc logging")
+                    .takes_value(false)
+            ).arg(
+                Arg::with_name("hide_json_rpc_logging_parameters")
+                    .long("hide-json-rpc-logging-parameters")
+                    .help("disables parameter printing in rpc logs")
+                    .takes_value(false)
+            ).arg(
+                Arg::with_name("anonymize_json_rpc_logging_source_ip")
+                    .long("anonymize-json-rpc-logging-source-ip")
+                    .help("enables ip anonymization in rpc logs")
+                    .takes_value(false)
             ).arg(
                 Arg::with_name("initial_sync_compaction")
                     .long("initial-sync-compaction")
@@ -429,10 +433,15 @@ impl Config {
             electrum_rpc_addr,
             electrum_txs_limit: value_t_or_exit!(m, "electrum_txs_limit", usize),
             electrum_banner,
-            rpc_logging_modes: m.values_of("rpc_logging_modes").map(|vals| {
-                let collected = vals.collect::<Vec<_>>();
-                RpcLoggingModes::from_values(&collected)
-            }),
+            rpc_logging: {
+                let params = RpcLogging {
+                    enabled: m.is_present("enable_json_rpc_logging"),
+                    hide_params: m.is_present("hide_json_rpc_logging_parameters"),
+                    anonymize_ip: m.is_present("anonymize_json_rpc_logging_source_ip"),
+                };
+                params.validate();
+                params
+            },
             http_addr,
             http_socket_file,
             monitoring_addr,
@@ -475,38 +484,17 @@ impl Config {
 }
 
 #[derive(Debug, Default, Clone)]
-pub struct RpcLoggingModes {
-    pub with_params: bool,
-    pub anonymised: bool,
+pub struct RpcLogging {
+    pub enabled: bool,
+    pub hide_params: bool,
+    pub anonymize_ip: bool,
 }
 
-impl RpcLoggingModes {
-    pub fn from_values(values: &[&str]) -> Self {
-        let mut modes = Self::default();
-        let mut no_params = false;
-
-        for v in values {
-            match *v {
-                "with-params" => modes.with_params = true,
-                "no-params"  => no_params = true,
-                "anonymised" => modes.anonymised = true,
-                _ => panic!("Unsupported RPC logging option: {}", v),
-            }
-        }
-
-        if modes.with_params && no_params {
-            panic!("Contradiction: 'with-params' and 'no-params' cannot both be set.");
-        }
-
-        if no_params {
-            modes.with_params = false;
+impl RpcLogging {
+    pub fn validate(&self) {
+        if !self.enabled && (self.hide_params || self.anonymize_ip) {
+            panic!("Flags '--hide-json-rpc-logging-parameters' or '--anonymize-json-rpc-logging-source-ip' require '--enable-json-rpc-logging'");
         }
-
-        modes
-    }
-
-    pub fn get_modes() -> Vec<&'static str> {
-        vec!["with-params", "no-params", "anonymised"]
     }
 }
 

src/electrum/server.rs

@@ -20,7 +20,7 @@ use bitcoin::consensus::encode::serialize_hex;
 #[cfg(feature = "liquid")]
 use elements::encode::serialize_hex;
 use crate::chain::Txid;
-use crate::config::{Config, RpcLoggingModes};
+use crate::config::{Config, RpcLogging};
 use crate::electrum::{get_electrum_height, ProtocolVersion};
 use crate::errors::*;
 use crate::metrics::{Gauge, HistogramOpts, HistogramVec, MetricOpts, Metrics};
@@ -94,7 +94,7 @@ fn get_status_hash(txs: Vec<(Txid, Option<BlockId>)>, query: &Query) -> Option<F
 
 macro_rules! conditionally_log_rpc_event {
     ($self:ident, $event:expr) => {
-        if $self.rpc_logging_modes.is_some() {
+        if $self.rpc_logging.enabled {
             $self.log_rpc_event($event);
         }
     };
@@ -111,7 +111,7 @@ struct Connection {
     txs_limit: usize,
     #[cfg(feature = "electrum-discovery")]
     discovery: Option<Arc<DiscoveryManager>>,
-    rpc_logging_modes: Option<RpcLoggingModes>,
+    rpc_logging: RpcLogging,
     salt: String,
 }
 
@@ -124,7 +124,7 @@ impl Connection {
         stats: Arc<Stats>,
         txs_limit: usize,
         #[cfg(feature = "electrum-discovery")] discovery: Option<Arc<DiscoveryManager>>,
-        rpc_logging_modes: Option<RpcLoggingModes>,
+        rpc_logging: RpcLogging,
         salt: String,
     ) -> Connection {
         Connection {
@@ -138,7 +138,7 @@ impl Connection {
             txs_limit,
             #[cfg(feature = "electrum-discovery")]
             discovery,
-            rpc_logging_modes,
+            rpc_logging,
             salt,
         }
     }
@@ -535,9 +535,8 @@ impl Connection {
     }
 
     fn log_rpc_event(&self, mut log: Value) {
-        let anonymize_ip = matches!(&self.rpc_logging_modes, Some(modes) if modes.anonymised);
         let real_ip = self.addr.ip().to_string();
-        let ip_to_log = if anonymize_ip {
+        let ip_to_log = if self.rpc_logging.anonymize_ip {
             self.hash_ip_with_salt(&real_ip)
         } else {
             real_ip
@@ -617,18 +616,11 @@ impl Connection {
                             "event": "rpc request",
                             "id": id,
                             "method": method,
-                            "params": match &self.rpc_logging_modes {
-                                Some(modes) => {
-                                    if modes.with_params {
-                                        json!(params)
-                                    } else {
-                                        Value::Null
-                                    }
-                                }
-                                None => {
+                            "params": if self.rpc_logging.hide_params {
                                     Value::Null
+                                } else {
+                                    json!(params)
                                 }
-                            }
                         })
                     );
 
@@ -876,7 +868,7 @@ impl RPC {
                     let query = Arc::clone(&query);
                     let stats = Arc::clone(&stats);
                     let garbage_sender = garbage_sender.clone();
-                    let rpc_logging_modes = config.rpc_logging_modes.clone();
+                    let rpc_logging = config.rpc_logging.clone();
                     #[cfg(feature = "electrum-discovery")]
                     let discovery = discovery.clone();
 
@@ -896,7 +888,7 @@ impl RPC {
                             txs_limit,
                             #[cfg(feature = "electrum-discovery")]
                             discovery,
-                            rpc_logging_modes,
+                            rpc_logging,
                             salt,
                         );
                         conn.run(receiver);

tests/common.rs

@@ -27,6 +27,7 @@ use electrs::{
     rest,
     signal::Waiter,
 };
+use electrs::config::RpcLogging;
 
 pub struct TestRunner {
     config: Arc<Config>,
@@ -109,7 +110,7 @@ impl TestRunner {
             utxos_limit: 100,
             electrum_txs_limit: 100,
             electrum_banner: "".into(),
-            rpc_logging_modes: None,
+            rpc_logging: RpcLogging::default(),
             zmq_addr: None,
 
             #[cfg(feature = "liquid")]