blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Lower a bunch of debug 

Can't afford to be printing on every transaction error, it will slow
the system down.
This commit is contained in:
Stephen Akridge 2019-03-28 11:45:34 -07:00 committed by sakridge
parent 92e1c4c531
commit 0482f153d0
4 changed files with 17 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/src/banking_stage.rs
View File

@ -224,7 +224,7 @@ impl BankingStage {
.filter_map(|(r, x)| match r { .filter_map(|(r, x)| match r {
Ok(_) => Some(x.clone()), Ok(_) => Some(x.clone()),
Err(TransactionError::InstructionError(index, err)) => { Err(TransactionError::InstructionError(index, err)) => {
info!("instruction error {:?}, {:?}", index, err); debug!("instruction error {:?}, {:?}", index, err);
Some(x.clone()) Some(x.clone())
} }
Err(ref e) => { Err(ref e) => {
@ -367,7 +367,7 @@ impl BankingStage {
let mut reqs_len = 0; let mut reqs_len = 0;
let mms_len = mms.len(); let mms_len = mms.len();
info!( debug!(
"@{:?} process start stalled for: {:?}ms batches: {}", "@{:?} process start stalled for: {:?}ms batches: {}",
timing::timestamp(), timing::timestamp(),
timing::duration_as_ms(&recv_start.elapsed()), timing::duration_as_ms(&recv_start.elapsed()),
@ -440,7 +440,7 @@ impl BankingStage {
); );
let total_time_s = timing::duration_as_s(&proc_start.elapsed()); let total_time_s = timing::duration_as_s(&proc_start.elapsed());
let total_time_ms = timing::duration_as_ms(&proc_start.elapsed()); let total_time_ms = timing::duration_as_ms(&proc_start.elapsed());
info!( debug!(
"@{:?} done processing transaction batches: {} time: {:?}ms reqs: {} reqs/s: {}", "@{:?} done processing transaction batches: {} time: {:?}ms reqs: {} reqs/s: {}",
timing::timestamp(), timing::timestamp(),
mms_len, mms_len,

14
core/src/rpc.rs
View File

@ -236,13 +236,13 @@ impl RpcSol for RpcSolImpl {
type Metadata = Meta; type Metadata = Meta;
fn confirm_transaction(&self, meta: Self::Metadata, id: String) -> Result<bool> { fn confirm_transaction(&self, meta: Self::Metadata, id: String) -> Result<bool> {
info!("confirm_transaction rpc request received: {:?}", id); debug!("confirm_transaction rpc request received: {:?}", id);
self.get_signature_status(meta, id) self.get_signature_status(meta, id)
.map(|status| status == RpcSignatureStatus::Confirmed) .map(|status| status == RpcSignatureStatus::Confirmed)
} }
fn get_account_info(&self, meta: Self::Metadata, id: String) -> Result<Account> { fn get_account_info(&self, meta: Self::Metadata, id: String) -> Result<Account> {
info!("get_account_info rpc request received: {:?}", id); debug!("get_account_info rpc request received: {:?}", id);
let pubkey = verify_pubkey(id)?; let pubkey = verify_pubkey(id)?;
meta.request_processor meta.request_processor
.read() .read()
@ -251,13 +251,13 @@ impl RpcSol for RpcSolImpl {
} }
fn get_balance(&self, meta: Self::Metadata, id: String) -> Result<u64> { fn get_balance(&self, meta: Self::Metadata, id: String) -> Result<u64> {
info!("get_balance rpc request received: {:?}", id); debug!("get_balance rpc request received: {:?}", id);
let pubkey = verify_pubkey(id)?; let pubkey = verify_pubkey(id)?;
Ok(meta.request_processor.read().unwrap().get_balance(&pubkey)) Ok(meta.request_processor.read().unwrap().get_balance(&pubkey))
} }
fn get_recent_blockhash(&self, meta: Self::Metadata) -> Result<String> { fn get_recent_blockhash(&self, meta: Self::Metadata) -> Result<String> {
info!("get_recent_blockhash rpc request received"); debug!("get_recent_blockhash rpc request received");
Ok(meta Ok(meta
.request_processor .request_processor
.read() .read()
@ -282,7 +282,7 @@ impl RpcSol for RpcSolImpl {
meta: Self::Metadata, meta: Self::Metadata,
id: String, id: String,
) -> Result<(usize, RpcSignatureStatus)> { ) -> Result<(usize, RpcSignatureStatus)> {
info!("get_signature_confirmation rpc request received: {:?}", id); debug!("get_signature_confirmation rpc request received: {:?}", id);
let signature = verify_signature(&id)?; let signature = verify_signature(&id)?;
let res = meta let res = meta
.request_processor .request_processor
@ -311,7 +311,7 @@ impl RpcSol for RpcSolImpl {
(0, RpcSignatureStatus::SignatureNotFound) (0, RpcSignatureStatus::SignatureNotFound)
} }
}; };
info!( debug!(
"get_signature_confirmation rpc request status: {:?}", "get_signature_confirmation rpc request status: {:?}",
status status
); );
@ -319,7 +319,7 @@ impl RpcSol for RpcSolImpl {
} }
fn get_transaction_count(&self, meta: Self::Metadata) -> Result<u64> { fn get_transaction_count(&self, meta: Self::Metadata) -> Result<u64> {
info!("get_transaction_count rpc request received"); debug!("get_transaction_count rpc request received");
meta.request_processor meta.request_processor
.read() .read()
.unwrap() .unwrap()

2
runtime/src/accounts.rs
View File

@ -861,7 +861,7 @@ impl Accounts {
for k in keys { for k in keys {
if locks.contains(k) { if locks.contains(k) {
error_counters.account_in_use += 1; error_counters.account_in_use += 1;
error!("Account in use: {:?}", k); debug!("Account in use: {:?}", k);
return Err(TransactionError::AccountInUse); return Err(TransactionError::AccountInUse);
} }
} }

12
runtime/src/system_program.rs
View File

@ -16,21 +16,21 @@ fn create_system_account(
program_id: &Pubkey, program_id: &Pubkey,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
if !system_program::check_id(&keyed_accounts[FROM_ACCOUNT_INDEX].account.owner) { if !system_program::check_id(&keyed_accounts[FROM_ACCOUNT_INDEX].account.owner) {
info!("CreateAccount: invalid account[from] owner"); debug!("CreateAccount: invalid account[from] owner");
Err(SystemError::SourceNotSystemAccount)?; Err(SystemError::SourceNotSystemAccount)?;
} }
if !keyed_accounts[TO_ACCOUNT_INDEX].account.data.is_empty() if !keyed_accounts[TO_ACCOUNT_INDEX].account.data.is_empty()
|| !system_program::check_id(&keyed_accounts[TO_ACCOUNT_INDEX].account.owner) || !system_program::check_id(&keyed_accounts[TO_ACCOUNT_INDEX].account.owner)
{ {
info!( debug!(
"CreateAccount: invalid argument; account {} already in use", "CreateAccount: invalid argument; account {} already in use",
keyed_accounts[TO_ACCOUNT_INDEX].unsigned_key() keyed_accounts[TO_ACCOUNT_INDEX].unsigned_key()
); );
Err(SystemError::AccountAlreadyInUse)?; Err(SystemError::AccountAlreadyInUse)?;
} }
if lamports > keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports { if lamports > keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports {
info!( debug!(
"CreateAccount: insufficient lamports ({}, need {})", "CreateAccount: insufficient lamports ({}, need {})",
keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports, lamports keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports, lamports
); );
@ -53,7 +53,7 @@ fn assign_account_to_program(
} }
fn move_lamports(keyed_accounts: &mut [KeyedAccount], lamports: u64) -> Result<(), SystemError> { fn move_lamports(keyed_accounts: &mut [KeyedAccount], lamports: u64) -> Result<(), SystemError> {
if lamports > keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports { if lamports > keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports {
info!( debug!(
"Move: insufficient lamports ({}, need {})", "Move: insufficient lamports ({}, need {})",
keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports, lamports keyed_accounts[FROM_ACCOUNT_INDEX].account.lamports, lamports
); );
@ -76,7 +76,7 @@ pub fn entrypoint(
// All system instructions require that accounts_keys[0] be a signer // All system instructions require that accounts_keys[0] be a signer
if keyed_accounts[FROM_ACCOUNT_INDEX].signer_key().is_none() { if keyed_accounts[FROM_ACCOUNT_INDEX].signer_key().is_none() {
info!("account[from] is unsigned"); debug!("account[from] is unsigned");
Err(InstructionError::MissingRequiredSignature)?; Err(InstructionError::MissingRequiredSignature)?;
} }
@ -96,7 +96,7 @@ pub fn entrypoint(
} }
.map_err(|e| InstructionError::CustomError(serialize(&e).unwrap())) .map_err(|e| InstructionError::CustomError(serialize(&e).unwrap()))
} else { } else {
info!("Invalid instruction data: {:?}", data); debug!("Invalid instruction data: {:?}", data);
Err(InstructionError::InvalidInstructionData) Err(InstructionError::InvalidInstructionData)
} }
} }