Merge pull request #1764 from 0chain/error-log-stderr

Error log stderr

Author: dabasov

core/client/http.go

@@ -3,13 +3,13 @@ package client
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/http"
 	"net/url"
 	"sync"
 
 	"github.com/0chain/errors"
 	"github.com/0chain/gosdk/core/conf"
+	"github.com/0chain/gosdk/core/logger"
 	"github.com/0chain/gosdk/core/util"
 	"github.com/shopspring/decimal"
 )
@@ -57,7 +57,7 @@ func MakeSCRestAPICallToSharder(scAddress string, relativePath string, params ma
 			urlString := fmt.Sprintf("%v/%v%v%v", sharder, restApiUrl, scAddress, relativePath)
 			urlObj, err := url.Parse(urlString)
 			if err != nil {
-				log.Println(err.Error())
+				logger.GetLogger().Error("Error parsing URL: ", err.Error())
 				return
 			}
 			q := urlObj.Query()
@@ -68,14 +68,14 @@ func MakeSCRestAPICallToSharder(scAddress string, relativePath string, params ma
 
 			req, err := util.NewHTTPGetRequest(urlObj.String())
 			if err != nil {
-				log.Println("Error creating request", err.Error())
+				logger.GetLogger().Error("Error creating request: ", err.Error())
 				return
 			}
 
 			response, err := req.Get()
 			if err != nil {
 				nodeClient.sharders.Fail(sharder)
-				log.Println("Error getting response", err.Error())
+				logger.GetLogger().Error("Error getting response: ", err.Error())
 				return
 			}
 

core/logger/logger.go

@@ -46,7 +46,7 @@ func (l *Logger) Init(lvl int, prefix string) {
 	l.SetLevel(lvl)
 	l.prefix = prefix
 	l.logDebug = log.New(os.Stderr, prefix+": "+strDEBUG, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
-	l.logInfo = log.New(os.Stderr, prefix+": "+strINFO, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
+	l.logInfo = log.New(os.Stdout, prefix+": "+strINFO, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
 	l.logError = log.New(os.Stderr, prefix+": "+strERROR, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
 	l.logFatal = log.New(os.Stderr, prefix+": "+strFATAL, log.Ldate|log.Ltime|log.Lmicroseconds|log.Lshortfile)
 }
@@ -85,7 +85,7 @@ func (l *Logger) SetLogFile(logFile io.Writer, verbose bool) {
 	fLogs := []io.Writer{logFile}
 	if verbose {
 		dLogs = append(dLogs, os.Stderr)
-		iLogs = append(iLogs, os.Stderr)
+		iLogs = append(iLogs, os.Stdout)
 		eLogs = append(eLogs, os.Stderr)
 		fLogs = append(fLogs, os.Stderr)
 	}

zcnbridge/bridge.go

@@ -159,7 +159,7 @@ func (b *BridgeClient) AddEthereumAuthorizers(configDir string) {
 	cfg.AddConfigPath(configDir)
 	cfg.SetConfigName("authorizers")
 	if err := cfg.ReadInConfig(); err != nil {
-		fmt.Println(err)
+		Logger.Error(err)
 		return
 	}
 
@@ -168,32 +168,32 @@ func (b *BridgeClient) AddEthereumAuthorizers(configDir string) {
 	for _, mnemonic := range mnemonics {
 		wallet, err := hdw.NewFromMnemonic(mnemonic)
 		if err != nil {
-			fmt.Printf("failed to read mnemonic: %v", err)
+			Logger.Error(fmt.Sprintf("failed to read mnemonic: %v", err))
 			continue
 		}
 
 		pathD := hdw.MustParseDerivationPath("m/44'/60'/0'/0/0")
 		account, err := wallet.Derive(pathD, true)
 		if err != nil {
-			fmt.Println(err)
+			Logger.Error(err)
 			continue
 		}
 
 		transaction, err := b.AddEthereumAuthorizer(context.TODO(), account.Address)
 		if err != nil || transaction == nil {
-			fmt.Printf("AddAuthorizer error: %v, Address: %s", err, account.Address.Hex())
+			Logger.Error(fmt.Sprintf("AddAuthorizer error: %v, Address: %s", err, account.Address.Hex()))
 			continue
 		}
 
 		status, err := ConfirmEthereumTransaction(transaction.Hash().String(), 100, time.Second*10)
 		if err != nil {
-			fmt.Println(err)
+			Logger.Error(err)
 		}
 
 		if status == 1 {
-			fmt.Printf("Authorizer has been added: %s\n", mnemonic)
+			Logger.Info(fmt.Sprintf("Authorizer has been added: %s\n", mnemonic))
 		} else {
-			fmt.Printf("Authorizer has failed to be added: %s\n", mnemonic)
+			Logger.Info(fmt.Sprintf("Authorizer has failed to be added: %s\n", mnemonic))
 		}
 	}
 }

zcnbridge/keystore.go

@@ -84,7 +84,7 @@ func DeleteAccount(homedir, address string) bool {
 	})
 
 	if err != nil && wallet == nil {
-		fmt.Printf("failed to find account %s, error: %s", address, err)
+		Logger.Error(fmt.Sprintf("failed to find account %s, error: %s", address, err))
 		return false
 	}
 
@@ -105,14 +105,16 @@ func AccountExists(homedir, address string) bool {
 	})
 
 	if err != nil && wallet == nil {
-		fmt.Printf("failed to find account %s, error: %s\n", address, err)
+		Logger.Error(fmt.Sprintf("failed to find account %s, error: %s", address, err))
 		return false
 	}
 
 	status, _ := wallet.Status()
 	url := wallet.URL()
 
-	fmt.Printf("Account exists. Status: %s, Path: %s\n", status, url)
+	Logger.Info(
+		fmt.Sprintf("Account exists. Status: %s, Path: %s", status, url),
+	)
 
 	return true
 }
@@ -127,8 +129,10 @@ func CreateKeyStorage(homedir, password string) error {
 	if err != nil {
 		return errors.Wrap(err, "failed to create keystore")
 	}
-	fmt.Printf("Created account: %s", account.Address.Hex())
-
+	Logger.Info(
+		fmt.Sprintf("Created account: %s", account.Address.Hex()),
+	)
+	
 	return nil
 }
 
@@ -185,7 +189,7 @@ func ImportAccount(homedir, mnemonic, password string, accountAddrIndex ...Accou
 
 	acc, err := ks.Find(account)
 	if err == nil {
-		fmt.Printf("Account already exists: %s\nPath: %s\n\n", acc.Address.Hex(), acc.URL.Path)
+		Logger.Error(fmt.Sprintf("Account already exists: %s\nPath: %s\n\n", acc.Address.Hex(), acc.URL.Path))
 		return acc.Address.Hex(), nil
 	}
 
@@ -196,7 +200,7 @@ func ImportAccount(homedir, mnemonic, password string, accountAddrIndex ...Accou
 		return "", errors.Wrap(err, "failed to get import private key")
 	}
 
-	fmt.Printf("Imported account %s to path: %s\n", acc.Address.Hex(), acc.URL.Path)
-
+	Logger.Info(fmt.Sprintf("Imported account %s to path: %s\n", acc.Address.Hex(), acc.URL.Path))
+	
 	return acc.Address.Hex(), nil
 }

zcnbridge/rest.go

@@ -73,7 +73,7 @@ func getAuthorizers(active bool) ([]*AuthorizerNode, error) {
 	}
 
 	if len(authorizers.Nodes) == 0 {
-		fmt.Println("no authorizers found")
+		Logger.Error("no authorizers found")
 		return nil, err
 	}
 

zcncore/ethwallet_base.go

@@ -9,7 +9,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto"
 	"golang.org/x/crypto/sha3"
-	"log"
 	"math"
 	"math/big"
 	"regexp"
@@ -251,16 +250,16 @@ func TransferEthTokens(fromPrivKey string, amountTokens, gasPrice int64) (string
 	hash := sha3.NewLegacyKeccak256()
 	hash.Write(transferFnSignature)
 	methodID := hash.Sum(nil)[:4]
-	fmt.Println(hexutil.Encode(methodID)) // 0xa9059cbb
+	logging.Info(hexutil.Encode(methodID)) // 0xa9059cbb
 
 	paddedAddress := common.LeftPadBytes(toAddress.Bytes(), 32)
-	fmt.Println(hexutil.Encode(paddedAddress)) // 0x0000000000000000000000004592d8f8d7b001e72cb26a73e4fa1806a51ac79d
+	logging.Info(hexutil.Encode(paddedAddress)) // 0x0000000000000000000000004592d8f8d7b001e72cb26a73e4fa1806a51ac79d
 
 	amount := new(big.Int)
 	amount.SetInt64(amountTokens)
 
 	paddedAmount := common.LeftPadBytes(amount.Bytes(), 32)
-	fmt.Println(hexutil.Encode(paddedAmount)) // 0x00000000000000000000000000000000000000000000003635c9adc5dea00000
+	logging.Info(hexutil.Encode(paddedAmount)) // 0x00000000000000000000000000000000000000000000003635c9adc5dea00000
 
 	var data []byte
 	data = append(data, methodID...)
@@ -272,7 +271,7 @@ func TransferEthTokens(fromPrivKey string, amountTokens, gasPrice int64) (string
 		Data: data,
 	})
 	if err != nil {
-		log.Fatal(err)
+		logging.Fatal(err)
 	}
 
 	txData := &types.LegacyTx{

zcncore/get_data.go

@@ -177,7 +177,7 @@ func getWallet(walletStr string) (*zcncrypto.Wallet, error) {
 	var w zcncrypto.Wallet
 	err := json.Unmarshal([]byte(walletStr), &w)
 	if err != nil {
-		fmt.Printf("error while parsing wallet string.\n%v\n", err)
+		logging.Error(fmt.Sprintf("error while parsing wallet string.\n%v\n", err))
 		return nil, err
 	}
 

znft/keystore.go

@@ -30,7 +30,7 @@ func DeleteAccount(homedir, address string) bool {
 	})
 
 	if err != nil && wallet == nil {
-		fmt.Printf("failed to find account %s, error: %s", address, err)
+		Logger.Error(fmt.Sprintf("failed to find account %s, error: %s", address, err))``
 		return false
 	}
 
@@ -54,15 +54,17 @@ func AccountExists(homedir, address string) bool {
 	})
 
 	if err != nil && wallet == nil {
-		fmt.Printf("failed to find account %s, error: %s\n", address, err)
+		Logger.Error(fmt.Sprintf("failed to find account %s, error: %s", address, err))
 		return false
 	}
 
 	status, _ := wallet.Status()
 	url := wallet.URL()
 
-	fmt.Printf("Account exists. Status: %s, Path: %s\n", status, url)
-
+	Logger.Info(
+		fmt.Sprintf("Account exists. Status: %s, Path: %s", status, url),
+	)
+	
 	return true
 }
 
@@ -74,8 +76,10 @@ func CreateKeyStorage(homedir, password string) error {
 	if err != nil {
 		return errors.Wrap(err, "failed to create keystore")
 	}
-	fmt.Printf("Created account: %s", account.Address.Hex())
-
+	Logger.Info(
+		fmt.Sprintf("Created account: %s", account.Address.Hex()),
+	)
+	
 	return nil
 }
 
@@ -140,7 +144,9 @@ func ImportAccount(homedir, mnemonic, password string) (string, error) {
 	// 3. Find key
 	acc, err := ks.Find(account)
 	if err == nil {
-		fmt.Printf("Account already exists: %s\nPath: %s\n\n", acc.Address.Hex(), acc.URL.Path)
+		Logger.Info(
+			fmt.Sprintf("Account already exists: %s\nPath: %s\n\n", acc.Address.Hex(), acc.URL.Path),
+		)
 		return acc.Address.Hex(), nil
 	}
 
@@ -150,7 +156,9 @@ func ImportAccount(homedir, mnemonic, password string) (string, error) {
 		return "", errors.Wrap(err, "failed to get import private key")
 	}
 
-	fmt.Printf("Imported account %s to path: %s\n", acc.Address.Hex(), acc.URL.Path)
-
+	Logger.Info(
+		fmt.Sprintf("Imported account %s to path: %s\n", acc.Address.Hex(), acc.URL.Path),
+	)
+	
 	return acc.Address.Hex(), nil
 }

znft/znft.go

@@ -59,8 +59,7 @@ func GetConfigDir() string {
 	var configDir string
 	home, err := os.UserHomeDir()
 	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
+		logger.GetLogger().Fatal(err)
 	}
 	configDir = home + "/.zcn"
 	return configDir