Adjust log levels

Seulgi Kim · Seulgi Kim · commit fecba0511f13 · 2019-04-01T12:35:25.000+09:00
diff --git a/core/src/blockchain/blockchain.rs b/core/src/blockchain/blockchain.rs
@@ -134,7 +134,7 @@ impl BlockChain {
         ctrace!(BLOCKCHAIN, "Inserting block #{}({}) to the blockchain.", new_header.number(), new_block_hash);
 
         if self.is_known(&new_block_hash) {
-            ctrace!(BLOCKCHAIN, "Block #{}({}) is already known.", new_header.number(), new_block_hash);
+            cdebug!(BLOCKCHAIN, "Block #{}({}) is already known.", new_header.number(), new_block_hash);
             return ImportRoute::none()
         }
 
@@ -194,7 +194,7 @@ impl BlockChain {
         if parent_details_of_new_block.total_score + new_header.score() > self.best_proposal_block_detail().total_score
             && engine.can_change_canon_chain(&new_header)
         {
-            ctrace!(
+            cinfo!(
                 BLOCKCHAIN,
                 "Block #{}({}) has higher total score, changing the best proposal/canonical chain.",
                 new_header.number(),
diff --git a/core/src/client/client.rs b/core/src/client/client.rs
@@ -536,7 +536,7 @@ impl EngineClient for Client {
         match self.io_channel.lock().send(ClientIoMessage::UpdateBestAsCommitted(block_hash)) {
             Ok(_) => {}
             Err(e) => {
-                cdebug!(CLIENT, "Error while triggering the best block update: {}", e);
+                cerror!(CLIENT, "Error while triggering the best block update: {}", e);
             }
         }
     }
@@ -618,15 +618,15 @@ impl BlockChainClient for Client {
         let queue_size = self.queue_transactions.load(AtomicOrdering::Relaxed);
         ctrace!(EXTERNAL_PARCEL, "Queue size: {}", queue_size);
         if queue_size > MAX_MEM_POOL_SIZE {
-            debug!("Ignoring {} transactions: queue is full", transactions.len());
+            cwarn!(EXTERNAL_PARCEL, "Ignoring {} transactions: queue is full", transactions.len());
         } else {
             let len = transactions.len();
             match self.io_channel.lock().send(ClientIoMessage::NewTransactions(transactions, peer_id)) {
                 Ok(_) => {
                     self.queue_transactions.fetch_add(len, AtomicOrdering::SeqCst);
                 }
                 Err(e) => {
-                    debug!("Ignoring {} transactions: error queueing: {}", len, e);
+                    cwarn!(EXTERNAL_PARCEL, "Ignoring {} transactions: error queueing: {}", len, e);
                 }
             }
         }
@@ -793,7 +793,7 @@ impl ImportSealedBlock for Client {
             let header = block.header().clone();
 
             let route = self.importer.commit_block(block, &header, &block_data, self);
-            ctrace!(CLIENT, "Imported sealed block #{} ({})", number, h);
+            cinfo!(CLIENT, "Imported sealed block #{} ({})", number, h);
             route
         };
         let (enacted, retracted) = self.importer.calculate_enacted_retracted(&[route]);
diff --git a/core/src/client/importer.rs b/core/src/client/importer.rs
@@ -381,7 +381,7 @@ impl Importer {
             ctrace!(CLIENT, "Importing header {}", header.number());
 
             if bad.contains(&hash) || bad.contains(header.parent_hash()) {
-                ctrace!(CLIENT, "Bad header detected : {}", hash);
+                cinfo!(CLIENT, "Bad header detected : {}", hash);
                 bad.insert(hash);
                 continue
             }
diff --git a/core/src/consensus/signer.rs b/core/src/consensus/signer.rs
@@ -49,7 +49,7 @@ impl EngineSigner {
         self.account_provider = ap;
         self.signer = Some((address, public));
         self.decrypted_account = None;
-        cdebug!(ENGINE, "Setting Engine signer to {}", address);
+        cinfo!(ENGINE, "Setting Engine signer to {}", address);
     }
 
     // TODO: remove decrypted_account after some timeout
@@ -61,7 +61,7 @@ impl EngineSigner {
         self.account_provider = ap;
         self.signer = Some((address, public));
         self.decrypted_account = Some(account);
-        cdebug!(ENGINE, "Setting Engine signer to {} (retaining)", address);
+        cinfo!(ENGINE, "Setting Engine signer to {} (retaining)", address);
     }
 
     /// Sign a consensus message hash.
diff --git a/core/src/consensus/tendermint/worker.rs b/core/src/consensus/tendermint/worker.rs
@@ -198,7 +198,7 @@ impl Worker {
                     match msg {
                         Ok((extension, client)) => (extension, client),
                         Err(crossbeam::RecvError) => {
-                            cwarn!(ENGINE, "The tendermint extension is not initalized.");
+                            cerror!(ENGINE, "The tendermint extension is not initalized.");
                             return
                         }
                     }
@@ -207,7 +207,7 @@ impl Worker {
                     match msg {
                         Ok(()) => {},
                         Err(crossbeam::RecvError) => {
-                            cwarn!(ENGINE, "The quit channel for tendermint thread had been closed.");
+                            cerror!(ENGINE, "The quit channel for tendermint thread had been closed.");
                         }
                     }
                     return
@@ -323,7 +323,7 @@ impl Worker {
                                 inner.get_all_votes_and_authors(&vote_step, &requested, result);
                             }
                             Err(crossbeam::RecvError) => {
-                                cwarn!(ENGINE, "The event channel for tendermint thread had been closed.");
+                                cerror!(ENGINE, "The event channel for tendermint thread had been closed.");
                                 break
                             }
                         }
@@ -332,7 +332,7 @@ impl Worker {
                         match msg {
                             Ok(()) => {},
                             Err(crossbeam::RecvError) => {
-                                cwarn!(ENGINE, "The quit channel for tendermint thread had been closed.");
+                                cerror!(ENGINE, "The quit channel for tendermint thread had been closed.");
                             }
                         }
                         break
diff --git a/core/src/consensus/vote_collector.rs b/core/src/consensus/vote_collector.rs
@@ -120,14 +120,14 @@ impl<M: Message + Default + Encodable + Debug> VoteCollector<M> {
 
         let is_known = read_guard.get(&message.round()).map_or(false, |c| c.messages.contains(message));
         if is_known {
-            ctrace!(ENGINE, "Known message: {:?}.", message);
+            cdebug!(ENGINE, "Known message: {:?}.", message);
             return true
         }
 
         // The reason not using `message.round() <= oldest` is to allow precommit messages on Commit step.
         let is_old = read_guard.keys().next().map_or(true, |oldest| message.round() < oldest);
         if is_old {
-            ctrace!(ENGINE, "Old message {:?}.", message);
+            cdebug!(ENGINE, "Old message {:?}.", message);
             return true
         }
 
diff --git a/core/src/miner/miner.rs b/core/src/miner/miner.rs
@@ -237,15 +237,15 @@ impl Miner {
             );
 
             if should_disable_sealing {
-                ctrace!(MINER, "Miner sleeping");
+                cdebug!(MINER, "Miner sleeping");
                 sealing_work.enabled = false;
                 sealing_work.queue.reset();
                 false
             } else {
                 true
             }
         } else {
-            ctrace!(MINER, "requires_reseal: sealing is disabled");
+            cdebug!(MINER, "requires_reseal: sealing is disabled");
             false
         }
     }
@@ -500,7 +500,7 @@ impl Miner {
                 Err(e) => {
                     invald_tx_users.insert(signer_public);
                     invalid_transactions.push(hash);
-                    cdebug!(
+                    cinfo!(
                         MINER,
                         "Error adding transaction to block: number={}. tx_hash={:?}, Error: {:?}",
                         block_number,
@@ -515,7 +515,7 @@ impl Miner {
                 } // imported ok
             }
         }
-        ctrace!(MINER, "Pushed {}/{} transactions", tx_count, tx_total);
+        cdebug!(MINER, "Pushed {}/{} transactions", tx_count, tx_total);
 
         let transactions_root = {
             let parent_hash = open_block.header().parent_hash();
@@ -551,7 +551,7 @@ impl Miner {
             && !self.options.force_sealing
             && Instant::now() <= *self.next_mandatory_reseal.read()
         {
-            ctrace!(MINER, "seal_block_internally: no sealing.");
+            cdebug!(MINER, "seal_block_internally: no sealing.");
             return false
         }
         ctrace!(MINER, "seal_block_internally: attempting internal seal.");
diff --git a/core/src/verification/queue/mod.rs b/core/src/verification/queue/mod.rs
@@ -97,7 +97,7 @@ impl QueueSignal {
         if !self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) {
             let channel = self.message_channel.lock().clone();
             if let Err(e) = channel.send_sync(self.message.clone()) {
-                debug!("Error sending verified message: {:?}", e);
+                cwarn!(ENGINE, "Error sending verified message: {:?}", e);
             }
         }
     }
@@ -111,7 +111,7 @@ impl QueueSignal {
         if !self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) {
             let channel = self.message_channel.lock().clone();
             if let Err(e) = channel.send(self.message.clone()) {
-                debug!("Error sending verified message: {:?}", e);
+                cwarn!(ENGINE, "Error sending verified message: {:?}", e);
             }
         }
     }
diff --git a/sync/src/transaction/extension.rs b/sync/src/transaction/extension.rs
@@ -121,7 +121,7 @@ impl NetworkExtension<Never> for Extension {
                         for unverified in transactions.iter() {
                             peer.push(*unverified);
                         }
-                        cdebug!(SYNC_TX, "Receive {} transactions from {}", transactions.len(), token);
+                        cinfo!(SYNC_TX, "Receive {} transactions from {}", transactions.len(), token);
                         ctrace!(SYNC_TX, "Receive {:?}", transactions);
                     } else {
                         cwarn!(SYNC_TX, "Message from {} but it's already removed", token);
@@ -161,7 +161,7 @@ impl Extension {
             for h in unsent_hashes.iter() {
                 peer.push(*h);
             }
-            cdebug!(SYNC_TX, "Send {} transactions to {}", unsent.len(), token);
+            cinfo!(SYNC_TX, "Send {} transactions to {}", unsent.len(), token);
             ctrace!(SYNC_TX, "Send {:?}", unsent_hashes);
             self.api.send(token, Arc::new(Message::Transactions(unsent).rlp_bytes().into_vec()));
         }

Original file line number	Diff line number	Diff line change
`@@ -536,7 +536,7 @@ impl EngineClient for Client {`
`536`	`536`	`match self.io_channel.lock().send(ClientIoMessage::UpdateBestAsCommitted(block_hash)) {`
`537`	`537`	`Ok(_) => {}`
`538`	`538`	`Err(e) => {`
`539`		`- cdebug!(CLIENT, "Error while triggering the best block update: {}", e);`
	`539`	`+ cerror!(CLIENT, "Error while triggering the best block update: {}", e);`
`540`	`540`	`}`
`541`	`541`	`}`
`542`	`542`	`}`
`@@ -618,15 +618,15 @@ impl BlockChainClient for Client {`
`618`	`618`	`let queue_size = self.queue_transactions.load(AtomicOrdering::Relaxed);`
`619`	`619`	`ctrace!(EXTERNAL_PARCEL, "Queue size: {}", queue_size);`
`620`	`620`	`if queue_size > MAX_MEM_POOL_SIZE {`
`621`		`- debug!("Ignoring {} transactions: queue is full", transactions.len());`
	`621`	`+ cwarn!(EXTERNAL_PARCEL, "Ignoring {} transactions: queue is full", transactions.len());`
`622`	`622`	`} else {`
`623`	`623`	`let len = transactions.len();`
`624`	`624`	`match self.io_channel.lock().send(ClientIoMessage::NewTransactions(transactions, peer_id)) {`
`625`	`625`	`Ok(_) => {`
`626`	`626`	`self.queue_transactions.fetch_add(len, AtomicOrdering::SeqCst);`
`627`	`627`	`}`
`628`	`628`	`Err(e) => {`
`629`		`- debug!("Ignoring {} transactions: error queueing: {}", len, e);`
	`629`	`+ cwarn!(EXTERNAL_PARCEL, "Ignoring {} transactions: error queueing: {}", len, e);`
`630`	`630`	`}`
`631`	`631`	`}`
`632`	`632`	`}`
`@@ -793,7 +793,7 @@ impl ImportSealedBlock for Client {`
`793`	`793`	`let header = block.header().clone();`
`794`	`794`
`795`	`795`	`let route = self.importer.commit_block(block, &header, &block_data, self);`
`796`		`- ctrace!(CLIENT, "Imported sealed block #{} ({})", number, h);`
	`796`	`+ cinfo!(CLIENT, "Imported sealed block #{} ({})", number, h);`
`797`	`797`	`route`
`798`	`798`	`};`
`799`	`799`	`let (enacted, retracted) = self.importer.calculate_enacted_retracted(&[route]);`
Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,7 @@ impl Importer {`
`381`	`381`	`ctrace!(CLIENT, "Importing header {}", header.number());`
`382`	`382`
`383`	`383`	`if bad.contains(&hash) \|\| bad.contains(header.parent_hash()) {`
`384`		`- ctrace!(CLIENT, "Bad header detected : {}", hash);`
	`384`	`+ cinfo!(CLIENT, "Bad header detected : {}", hash);`
`385`	`385`	`bad.insert(hash);`
`386`	`386`	`continue`
`387`	`387`	`}`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ impl Worker {`
`198`	`198`	`match msg {`
`199`	`199`	`Ok((extension, client)) => (extension, client),`
`200`	`200`	`Err(crossbeam::RecvError) => {`
`201`		`- cwarn!(ENGINE, "The tendermint extension is not initalized.");`
	`201`	`+ cerror!(ENGINE, "The tendermint extension is not initalized.");`
`202`	`202`	`return`
`203`	`203`	`}`
`204`	`204`	`}`
`@@ -207,7 +207,7 @@ impl Worker {`
`207`	`207`	`match msg {`
`208`	`208`	`Ok(()) => {},`
`209`	`209`	`Err(crossbeam::RecvError) => {`
`210`		`- cwarn!(ENGINE, "The quit channel for tendermint thread had been closed.");`
	`210`	`+ cerror!(ENGINE, "The quit channel for tendermint thread had been closed.");`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`	`return`
`@@ -323,7 +323,7 @@ impl Worker {`
`323`	`323`	`inner.get_all_votes_and_authors(&vote_step, &requested, result);`
`324`	`324`	`}`
`325`	`325`	`Err(crossbeam::RecvError) => {`
`326`		`- cwarn!(ENGINE, "The event channel for tendermint thread had been closed.");`
	`326`	`+ cerror!(ENGINE, "The event channel for tendermint thread had been closed.");`
`327`	`327`	`break`
`328`	`328`	`}`
`329`	`329`	`}`
`@@ -332,7 +332,7 @@ impl Worker {`
`332`	`332`	`match msg {`
`333`	`333`	`Ok(()) => {},`
`334`	`334`	`Err(crossbeam::RecvError) => {`
`335`		`- cwarn!(ENGINE, "The quit channel for tendermint thread had been closed.");`
	`335`	`+ cerror!(ENGINE, "The quit channel for tendermint thread had been closed.");`
`336`	`336`	`}`
`337`	`337`	`}`
`338`	`338`	`break`
Original file line number	Diff line number	Diff line change
`@@ -120,14 +120,14 @@ impl<M: Message + Default + Encodable + Debug> VoteCollector<M> {`
`120`	`120`
`121`	`121`	`let is_known = read_guard.get(&message.round()).map_or(false, \|c\| c.messages.contains(message));`
`122`	`122`	`if is_known {`
`123`		`- ctrace!(ENGINE, "Known message: {:?}.", message);`
	`123`	`+ cdebug!(ENGINE, "Known message: {:?}.", message);`
`124`	`124`	`return true`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	// The reason not using `message.round() <= oldest` is to allow precommit messages on Commit step.
`128`	`128`	`let is_old = read_guard.keys().next().map_or(true, \|oldest\| message.round() < oldest);`
`129`	`129`	`if is_old {`
`130`		`- ctrace!(ENGINE, "Old message {:?}.", message);`
	`130`	`+ cdebug!(ENGINE, "Old message {:?}.", message);`
`131`	`131`	`return true`
`132`	`132`	`}`
`133`	`133`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ impl QueueSignal {`
`97`	`97`	`if !self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) {`
`98`	`98`	`let channel = self.message_channel.lock().clone();`
`99`	`99`	`if let Err(e) = channel.send_sync(self.message.clone()) {`
`100`		`- debug!("Error sending verified message: {:?}", e);`
	`100`	`+ cwarn!(ENGINE, "Error sending verified message: {:?}", e);`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`}`
`@@ -111,7 +111,7 @@ impl QueueSignal {`
`111`	`111`	`if !self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) {`
`112`	`112`	`let channel = self.message_channel.lock().clone();`
`113`	`113`	`if let Err(e) = channel.send(self.message.clone()) {`
`114`		`- debug!("Error sending verified message: {:?}", e);`
	`114`	`+ cwarn!(ENGINE, "Error sending verified message: {:?}", e);`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ impl NetworkExtension<Never> for Extension {`
`121`	`121`	`for unverified in transactions.iter() {`
`122`	`122`	`peer.push(*unverified);`
`123`	`123`	`}`
`124`		`- cdebug!(SYNC_TX, "Receive {} transactions from {}", transactions.len(), token);`
	`124`	`+ cinfo!(SYNC_TX, "Receive {} transactions from {}", transactions.len(), token);`
`125`	`125`	`ctrace!(SYNC_TX, "Receive {:?}", transactions);`
`126`	`126`	`} else {`
`127`	`127`	`cwarn!(SYNC_TX, "Message from {} but it's already removed", token);`
`@@ -161,7 +161,7 @@ impl Extension {`
`161`	`161`	`for h in unsent_hashes.iter() {`
`162`	`162`	`peer.push(*h);`
`163`	`163`	`}`
`164`		`- cdebug!(SYNC_TX, "Send {} transactions to {}", unsent.len(), token);`
	`164`	`+ cinfo!(SYNC_TX, "Send {} transactions to {}", unsent.len(), token);`
`165`	`165`	`ctrace!(SYNC_TX, "Send {:?}", unsent_hashes);`
`166`	`166`	`self.api.send(token, Arc::new(Message::Transactions(unsent).rlp_bytes().into_vec()));`
`167`	`167`	`}`