d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-31 15:10:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

New logging system (#319)

Browse Source 
* First pass at adding new logging system

* NewLogger

* NewLogger

* WIP

* silly bug fix

* :D removed files

* removed old logging interface

* added tests

* added tests

* Started to add new lines to all f calls

* Added subsystem log types

* Logger improvements

* Further performance improvements

* changes to logger and sublogger creation

* Renamed Logging types

* removed old print statement

* changes based on feedback

* moved sublogger types to own file

* :)

* added console as output type

* added get level command

* added get/set log level via grpc command

* added check for output being empty for migration support

* first pass at log rotation

* added log rotation

* :D derp fixed

* added tests

* changes based on feedback

* changed log type

* comments

* renamed file -> fileSettings

* typo fix

* changes based on feedback

* gofmt ran on additional files

* gofmt ran on additional files
This commit is contained in:
Andrew
2019-07-07 05:20:31 +10:00
committed by Adrian Gallagher
parent 7112a89491
commit 3de1d94e5f
137 changed files with 2920 additions and 1650 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
engine/addr_helpers_test.go
View File

@@ -1,64 +1,64 @@
package engine
import (
"testing"
"github.com/thrasher-/gocryptotrader/currency"
)
const (
testBTCAddress = "1F1tAaz5x1HUXrCNLbtMDqcw6o5GNn4xqX"
)
func TestSeed(t *testing.T) {
var d DepositAddressStore
u := map[string]map[string]string{
"BITSTAMP": map[string]string{
"BTC": testBTCAddress,
},
}
d.Seed(u)
r, err := d.GetDepositAddress("BITSTAMP", currency.BTC)
if err != nil {
t.Error("unexpected result")
}
if r != testBTCAddress {
t.Error("unexpected result")
}
}
func TestGetDepositAddress(t *testing.T) {
var d DepositAddressStore
_, err := d.GetDepositAddress("", currency.BTC)
if err != ErrDepositAddressStoreIsNil {
t.Error("non-error on non-existent exchange")
}
d.Store = map[string]map[string]string{
"BITSTAMP": map[string]string{
"BTC": testBTCAddress,
},
}
_, err = d.GetDepositAddress("", currency.BTC)
if err != ErrExchangeNotFound {
t.Error("non-error on non-existent exchange")
}
var r string
r, err = d.GetDepositAddress("BiTStAmP", currency.NewCode("bTC"))
if err != nil {
t.Error("unexpected err: ", err)
}
if r != testBTCAddress {
t.Error("unexpected BTC address: ", r)
}
_, err = d.GetDepositAddress("BiTStAmP", currency.LTC)
if err != ErrDepositAddressNotFound {
t.Error("unexpected err: ", err)
}
}
package engine
import (
"testing"
"github.com/thrasher-/gocryptotrader/currency"
)
const (
testBTCAddress = "1F1tAaz5x1HUXrCNLbtMDqcw6o5GNn4xqX"
)
func TestSeed(t *testing.T) {
var d DepositAddressStore
u := map[string]map[string]string{
"BITSTAMP": {
"BTC": testBTCAddress,
},
}
d.Seed(u)
r, err := d.GetDepositAddress("BITSTAMP", currency.BTC)
if err != nil {
t.Error("unexpected result")
}
if r != testBTCAddress {
t.Error("unexpected result")
}
}
func TestGetDepositAddress(t *testing.T) {
var d DepositAddressStore
_, err := d.GetDepositAddress("", currency.BTC)
if err != ErrDepositAddressStoreIsNil {
t.Error("non-error on non-existent exchange")
}
d.Store = map[string]map[string]string{
"BITSTAMP": {
"BTC": testBTCAddress,
},
}
_, err = d.GetDepositAddress("", currency.BTC)
if err != ErrExchangeNotFound {
t.Error("non-error on non-existent exchange")
}
var r string
r, err = d.GetDepositAddress("BiTStAmP", currency.NewCode("bTC"))
if err != nil {
t.Error("unexpected err: ", err)
}
if r != testBTCAddress {
t.Error("unexpected BTC address: ", r)
}
_, err = d.GetDepositAddress("BiTStAmP", currency.LTC)
if err != ErrDepositAddressNotFound {
t.Error("unexpected err: ", err)
}
}

8
engine/comms_relayer.go
View File

@@ -33,7 +33,7 @@ func (c *commsManager) Start() (err error) {
}
}()
log.Debugln("Communications manager starting...")
log.Debugln(log.CommunicationMgr, "Communications manager starting...")
commsCfg := Bot.Config.GetCommunicationsConfig()
c.comms, err = communications.NewComm(&commsCfg)
if err != nil {
@@ -43,7 +43,7 @@ func (c *commsManager) Start() (err error) {
c.shutdown = make(chan struct{})
c.relayMsg = make(chan base.Event)
go c.run()
log.Debugln("Communications manager started.")
log.Debugln(log.CommunicationMgr, "Communications manager started.")
return nil
}
@@ -64,7 +64,7 @@ func (c *commsManager) Stop() error {
}
close(c.shutdown)
log.Debugln("Communications manager shutting down...")
log.Debugln(log.CommunicationMgr, "Communications manager shutting down...")
return nil
}
@@ -80,7 +80,7 @@ func (c *commsManager) run() {
// TO-DO shutdown comms connections for connected services (Slack etc)
atomic.CompareAndSwapInt32(&c.stopped, 1, 0)
atomic.CompareAndSwapInt32(&c.started, 1, 0)
log.Debugln("Communications manager shutdown.")
log.Debugln(log.CommunicationMgr, "Communications manager shutdown.")
}()
for {

10
engine/connection.go
View File

@@ -24,7 +24,7 @@ func (c *connectionManager) Start() error {
return errors.New("connection manager already started")
}
log.Debugln("Connection manager starting...")
log.Debugln(log.ConnectionMgr, "Connection manager starting...")
var err error
c.conn, err = connchecker.New(Bot.Config.ConnectionMonitor.DNSList,
Bot.Config.ConnectionMonitor.PublicDomainList,
@@ -34,7 +34,7 @@ func (c *connectionManager) Start() error {
return err
}
log.Debugln("Connection manager started.")
log.Debugln(log.ConnectionMgr, "Connection manager started.")
return nil
}
@@ -47,17 +47,17 @@ func (c *connectionManager) Stop() error {
return errors.New("connection manager is already stopped")
}
log.Debugln("Connection manager shutting down...")
log.Debugln(log.ConnectionMgr, "Connection manager shutting down...")
c.conn.Shutdown()
atomic.CompareAndSwapInt32(&c.stopped, 1, 0)
atomic.CompareAndSwapInt32(&c.started, 1, 0)
log.Debugln("Connection manager stopped.")
log.Debugln(log.ConnectionMgr, "Connection manager stopped.")
return nil
}
func (c *connectionManager) IsOnline() bool {
if c.conn == nil {
log.Warnf("Connection manager: IsOnline called but conn is nil")
log.Warnln(log.ConnectionMgr, "Connection manager: IsOnline called but conn is nil")
return false
}

163
engine/engine.go
View File

@@ -72,7 +72,8 @@ func NewFromSettings(settings *Settings) (*Engine, error) {
var b Engine
b.Config = &config.Cfg
log.Debugf("Loading config file %s...\n", settings.ConfigFile)
log.Debugf(log.Global, "Loading config file %s..\n", settings.ConfigFile)
err := b.Config.LoadConfig(settings.ConfigFile)
if err != nil {
return nil, fmt.Errorf("failed to load config. Err: %s", err)
@@ -83,19 +84,14 @@ func NewFromSettings(settings *Settings) (*Engine, error) {
return nil, fmt.Errorf("failed to open/create data directory: %s. Err: %s", settings.DataDir, err)
}
err = log.SetupLogger()
if err != nil {
log.Errorf("Failed to setup logger. Err: %s", err)
if *b.Config.Logging.Enabled {
log.SetupGlobalLogger()
log.SetupSubLoggers(b.Config.Logging.SubLoggers)
}
b.Settings.ConfigFile = settings.ConfigFile
b.Settings.DataDir = settings.DataDir
if *log.Logger.Enabled {
b.Settings.LogFile = log.LogPath
log.Debugf("Using log file: %s.\n", log.LogPath)
}
err = utils.AdjustGoMaxProcs(settings.GoMaxProcs)
if err != nil {
return nil, fmt.Errorf("unable to adjust runtime GOMAXPROCS value. Err: %s", err)
@@ -209,100 +205,101 @@ func ValidateSettings(b *Engine, s *Settings) {
// PrintSettings returns the engine settings
func PrintSettings(s *Settings) {
log.Debugln()
log.Debugf("ENGINE SETTINGS")
log.Debugf("- CORE SETTINGS:")
log.Debugf("\t Verbose mode: %v", s.Verbose)
log.Debugf("\t Enable dry run mode: %v", s.EnableDryRun)
log.Debugf("\t Enable all exchanges: %v", s.EnableAllExchanges)
log.Debugf("\t Enable all pairs: %v", s.EnableAllPairs)
log.Debugf("\t Enable coinmarketcap analaysis: %v", s.EnableCoinmarketcapAnalysis)
log.Debugf("\t Enable portfolio manager: %v", s.EnablePortfolioManager)
log.Debugf("\t Enable gPRC: %v", s.EnableGRPC)
log.Debugf("\t Enable gRPC Proxy: %v", s.EnableGRPCProxy)
log.Debugf("\t Enable websocket RPC: %v", s.EnableWebsocketRPC)
log.Debugf("\t Enable deprecated RPC: %v", s.EnableDeprecatedRPC)
log.Debugf("\t Enable comms relayer: %v", s.EnableCommsRelayer)
log.Debugf("\t Enable event manager: %v", s.EnableEventManager)
log.Debugf("\t Event manager sleep delay: %v", s.EventManagerDelay)
log.Debugf("\t Enable order manager: %v", s.EnableOrderManager)
log.Debugf("\t Enable exchange sync manager: %v", s.EnableExchangeSyncManager)
log.Debugf("\t Enable deposit address manager: %v\n", s.EnableDepositAddressManager)
log.Debugf("\t Enable ticker syncing: %v", s.EnableTickerSyncing)
log.Debugf("\t Enable orderbook syncing: %v", s.EnableOrderbookSyncing)
log.Debugf("\t Enable websocket routine: %v\n", s.EnableWebsocketRoutine)
log.Debugf("\t Enable NTP client: %v", s.EnableNTPClient)
log.Debugf("- FOREX SETTINGS:")
log.Debugf("\t Enable currency conveter: %v", s.EnableCurrencyConverter)
log.Debugf("\t Enable currency layer: %v", s.EnableCurrencyLayer)
log.Debugf("\t Enable fixer: %v", s.EnableFixer)
log.Debugf("\t Enable OpenExchangeRates: %v", s.EnableOpenExchangeRates)
log.Debugf("- EXCHANGE SETTINGS:")
log.Debugf("\t Enable exchange auto pair updates: %v", s.EnableExchangeAutoPairUpdates)
log.Debugf("\t Disable all exchange auto pair updates: %v", s.DisableExchangeAutoPairUpdates)
log.Debugf("\t Enable exchange websocket support: %v", s.EnableExchangeWebsocketSupport)
log.Debugf("\t Enable exchange verbose mode: %v", s.EnableExchangeVerbose)
log.Debugf("\t Enable exchange HTTP rate limiter: %v", s.EnableExchangeHTTPRateLimiter)
log.Debugf("\t Enable exchange HTTP debugging: %v", s.EnableExchangeHTTPDebugging)
log.Debugf("\t Exchange max HTTP request jobs: %v", s.MaxHTTPRequestJobsLimit)
log.Debugf("\t Exchange HTTP request timeout retry amount: %v", s.RequestTimeoutRetryAttempts)
log.Debugf("\t Exchange HTTP timeout: %v", s.ExchangeHTTPTimeout)
log.Debugf("\t Exchange HTTP user agent: %v", s.ExchangeHTTPUserAgent)
log.Debugf("\t Exchange HTTP proxy: %v\n", s.ExchangeHTTPProxy)
log.Debugf("- COMMON SETTINGS:")
log.Debugf("\t Global HTTP timeout: %v", s.GlobalHTTPTimeout)
log.Debugf("\t Global HTTP user agent: %v", s.GlobalHTTPUserAgent)
log.Debugf("\t Global HTTP proxy: %v", s.ExchangeHTTPProxy)
log.Debugln()
log.Debugln(log.Global)
log.Debugf(log.Global, "ENGINE SETTINGS")
log.Debugf(log.Global, "- CORE SETTINGS:")
log.Debugf(log.Global, "\t Verbose mode: %v", s.Verbose)
log.Debugf(log.Global, "\t Enable dry run mode: %v", s.EnableDryRun)
log.Debugf(log.Global, "\t Enable all exchanges: %v", s.EnableAllExchanges)
log.Debugf(log.Global, "\t Enable all pairs: %v", s.EnableAllPairs)
log.Debugf(log.Global, "\t Enable coinmarketcap analaysis: %v", s.EnableCoinmarketcapAnalysis)
log.Debugf(log.Global, "\t Enable portfolio manager: %v", s.EnablePortfolioManager)
log.Debugf(log.Global, "\t Enable gPRC: %v", s.EnableGRPC)
log.Debugf(log.Global, "\t Enable gRPC Proxy: %v", s.EnableGRPCProxy)
log.Debugf(log.Global, "\t Enable websocket RPC: %v", s.EnableWebsocketRPC)
log.Debugf(log.Global, "\t Enable deprecated RPC: %v", s.EnableDeprecatedRPC)
log.Debugf(log.Global, "\t Enable comms relayer: %v", s.EnableCommsRelayer)
log.Debugf(log.Global, "\t Enable event manager: %v", s.EnableEventManager)
log.Debugf(log.Global, "\t Event manager sleep delay: %v", s.EventManagerDelay)
log.Debugf(log.Global, "\t Enable order manager: %v", s.EnableOrderManager)
log.Debugf(log.Global, "\t Enable exchange sync manager: %v", s.EnableExchangeSyncManager)
log.Debugf(log.Global, "\t Enable deposit address manager: %v\n", s.EnableDepositAddressManager)
log.Debugf(log.Global, "\t Enable ticker syncing: %v", s.EnableTickerSyncing)
log.Debugf(log.Global, "\t Enable orderbook syncing: %v", s.EnableOrderbookSyncing)
log.Debugf(log.Global, "\t Enable websocket routine: %v\n", s.EnableWebsocketRoutine)
log.Debugf(log.Global, "\t Enable NTP client: %v", s.EnableNTPClient)
log.Debugf(log.Global, "- FOREX SETTINGS:")
log.Debugf(log.Global, "\t Enable currency conveter: %v", s.EnableCurrencyConverter)
log.Debugf(log.Global, "\t Enable currency layer: %v", s.EnableCurrencyLayer)
log.Debugf(log.Global, "\t Enable fixer: %v", s.EnableFixer)
log.Debugf(log.Global, "\t Enable OpenExchangeRates: %v", s.EnableOpenExchangeRates)
log.Debugf(log.Global, "- EXCHANGE SETTINGS:")
log.Debugf(log.Global, "\t Enable exchange auto pair updates: %v", s.EnableExchangeAutoPairUpdates)
log.Debugf(log.Global, "\t Disable all exchange auto pair updates: %v", s.DisableExchangeAutoPairUpdates)
log.Debugf(log.Global, "\t Enable exchange websocket support: %v", s.EnableExchangeWebsocketSupport)
log.Debugf(log.Global, "\t Enable exchange verbose mode: %v", s.EnableExchangeVerbose)
log.Debugf(log.Global, "\t Enable exchange HTTP rate limiter: %v", s.EnableExchangeHTTPRateLimiter)
log.Debugf(log.Global, "\t Enable exchange HTTP debugging: %v", s.EnableExchangeHTTPDebugging)
log.Debugf(log.Global, "\t Exchange max HTTP request jobs: %v", s.MaxHTTPRequestJobsLimit)
log.Debugf(log.Global, "\t Exchange HTTP request timeout retry amount: %v", s.RequestTimeoutRetryAttempts)
log.Debugf(log.Global, "\t Exchange HTTP timeout: %v", s.ExchangeHTTPTimeout)
log.Debugf(log.Global, "\t Exchange HTTP user agent: %v", s.ExchangeHTTPUserAgent)
log.Debugf(log.Global, "\t Exchange HTTP proxy: %v\n", s.ExchangeHTTPProxy)
log.Debugf(log.Global, "- COMMON SETTINGS:")
log.Debugf(log.Global, "\t Global HTTP timeout: %v", s.GlobalHTTPTimeout)
log.Debugf(log.Global, "\t Global HTTP user agent: %v", s.GlobalHTTPUserAgent)
log.Debugf(log.Global, "\t Global HTTP proxy: %v", s.ExchangeHTTPProxy)
log.Debugln(log.Global)
}
// Start starts the engine
func (e *Engine) Start() {
if e == nil {
log.Fatal("Engine instance is nil")
log.Errorln(log.Global, "Engine instance is nil")
os.Exit(1)
}
// Sets up internet connectivity monitor
if e.Settings.EnableConnectivityMonitor {
if err := e.ConnectionManager.Start(); err != nil {
log.Errorf("Connection manager unable to start: %v", err)
log.Errorf(log.Global, "Connection manager unable to start: %v", err)
}
}
if e.Settings.EnableNTPClient {
if err := e.NTPManager.Start(); err != nil {
log.Errorf("NTP manager unable to start: %v", err)
log.Errorf(log.Global, "NTP manager unable to start: %v", err)
}
}
e.Uptime = time.Now()
log.Debugf("Bot '%s' started.\n", e.Config.Name)
log.Debugf("Using data dir: %s\n", e.Settings.DataDir)
log.Debugf(log.Global, "Bot '%s' started.\n", e.Config.Name)
log.Debugf(log.Global, "Using data dir: %s\n", e.Settings.DataDir)
enabledExchanges := e.Config.CountEnabledExchanges()
if e.Settings.EnableAllExchanges {
enabledExchanges = len(e.Config.Exchanges)
}
log.Debugln()
log.Debugln("EXCHANGE COVERAGE")
log.Debugf("\t Available Exchanges: %d. Enabled Exchanges: %d.\n",
log.Debugln(log.Global, "EXCHANGE COVERAGE")
log.Debugf(log.Global, "\t Available Exchanges: %d. Enabled Exchanges: %d.\n",
len(e.Config.Exchanges), enabledExchanges)
if e.Settings.ExchangePurgeCredentials {
log.Debugln("Purging exchange API credentials.")
log.Debugln(log.Global, "Purging exchange API credentials.")
e.Config.PurgeExchangeAPICredentials()
}
log.Debugln("Setting up exchanges..")
log.Debugln(log.Global, "Setting up exchanges..")
SetupExchanges()
if len(e.Exchanges) == 0 {
log.Fatalf("No exchanges were able to be loaded. Exiting")
log.Errorln(log.Global, "No exchanges were able to be loaded. Exiting")
os.Exit(1)
}
if e.Settings.EnableCommsRelayer {
if err := e.CommsManager.Start(); err != nil {
log.Errorf("Communications manager unable to start: %v", err)
log.Errorf(log.Global, "Communications manager unable to start: %v\n", err)
}
}
@@ -329,7 +326,7 @@ func (e *Engine) Start() {
e.Settings.DataDir,
e.Settings.Verbose)
if err != nil {
log.Warn("currency updater system failed to start", err)
log.Errorf(log.Global, "currency updater system failed to start %v", err)
}
if e.Settings.EnableGRPC {
@@ -347,7 +344,7 @@ func (e *Engine) Start() {
if e.Settings.EnablePortfolioManager {
if err = e.PortfolioManager.Start(); err != nil {
log.Errorf("Fund manager unable to start: %v", err)
log.Errorf(log.Global, "Fund manager unable to start: %v", err)
}
}
@@ -358,7 +355,7 @@ func (e *Engine) Start() {
if e.Settings.EnableOrderManager {
if err = e.OrderManager.Start(); err != nil {
log.Errorf("Order manager unable to start: %v", err)
log.Errorf(log.Global, "Order manager unable to start: %v", err)
}
}
@@ -372,7 +369,7 @@ func (e *Engine) Start() {
e.ExchangeCurrencyPairManager, err = NewCurrencyPairSyncer(exchangeSyncCfg)
if err != nil {
log.Warnf("Unable to initialise exchange currency pair syncer. Err: %s", err)
log.Warnf(log.Global, "Unable to initialise exchange currency pair syncer. Err: %s", err)
} else {
go e.ExchangeCurrencyPairManager.Start()
}
@@ -388,7 +385,7 @@ func (e *Engine) Start() {
// Stop correctly shuts down engine saving configuration files
func (e *Engine) Stop() {
log.Debugln("Engine shutting down..")
log.Debugln(log.Global, "Engine shutting down..")
if len(portfolio.Portfolio.Addresses) != 0 {
e.Config.Portfolio = portfolio.Portfolio
@@ -396,46 +393,50 @@ func (e *Engine) Stop() {
if e.OrderManager.Started() {
if err := e.OrderManager.Stop(); err != nil {
log.Errorf("Order manager unable to stop. Error: %v", err)
log.Errorf(log.Global, "Order manager unable to stop. Error: %v", err)
}
}
if e.NTPManager.Started() {
if err := e.NTPManager.Stop(); err != nil {
log.Errorf("NTP manager unable to stop. Error: %v", err)
log.Errorf(log.Global, "NTP manager unable to stop. Error: %v", err)
}
}
if e.CommsManager.Started() {
if err := e.CommsManager.Stop(); err != nil {
log.Errorf("Communication manager unable to stop. Error: %v", err)
log.Errorf(log.Global, "Communication manager unable to stop. Error: %v", err)
}
}
if e.PortfolioManager.Started() {
if err := e.PortfolioManager.Stop(); err != nil {
log.Errorf("Fund manager unable to stop. Error: %v", err)
log.Errorf(log.Global, "Fund manager unable to stop. Error: %v", err)
}
}
if e.ConnectionManager.Started() {
if err := e.ConnectionManager.Stop(); err != nil {
log.Errorf("Connection manager unable to stop. Error: %v", err)
log.Errorf(log.Global, "Connection manager unable to stop. Error: %v", err)
}
}
if !e.Settings.EnableDryRun {
err := e.Config.SaveConfig(e.Settings.ConfigFile)
if err != nil {
log.Error("Unable to save config.")
log.Errorln(log.Global, "Unable to save config.")
} else {
log.Debugln("Config file saved successfully.")
log.Debugln(log.Global, "Config file saved successfully.")
}
}
// Wait for services to gracefully shutdown
e.ServicesWG.Wait()
log.Debugln("Exiting.")
log.CloseLogFile()
log.Debugln(log.Global, "Exiting.")
err := log.CloseLogger()
if err != nil {
fmt.Printf("Failed to close logger %v", err)
}
os.Exit(0)
}
@@ -447,7 +448,7 @@ func (e *Engine) handleInterrupt() {
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
go func() {
sig := <-c
log.Debugf("Captured %v, shutdown requested.", sig)
log.Debugf(log.Global, "Captured %v, shutdown requested.\n", sig)
close(e.Shutdown)
}()
}

22
engine/events.go
View File

@@ -126,7 +126,7 @@ func (e *Event) ExecuteAction() bool {
if strings.Contains(e.Action, ",") {
action := strings.Split(e.Action, ",")
if action[0] == ActionSMSNotify {
message := fmt.Sprintf("Event triggered: %s", e.String())
message := fmt.Sprintf("Event triggered: %s\n", e.String())
if action[1] == "ALL" {
Bot.CommsManager.PushEvent(base.Event{
Type: "event",
@@ -135,7 +135,7 @@ func (e *Event) ExecuteAction() bool {
}
}
} else {
log.Debugf("Event triggered: %s", e.String())
log.Debugf(log.EventMgr, "Event triggered: %s\n", e.String())
}
return true
}
@@ -143,7 +143,7 @@ func (e *Event) ExecuteAction() bool {
// String turns the structure event into a string
func (e *Event) String() string {
return fmt.Sprintf(
"If the %s [%s] %s on %s meets the following %v then %s.", e.Pair.String(),
"If the %s [%s] %s on %s meets the following %v then %s.\n", e.Pair.String(),
strings.ToUpper(e.Asset.String()), e.Item, e.Exchange, e.Condition, e.Action,
)
}
@@ -152,14 +152,14 @@ func (e *Event) processTicker() bool {
t, err := ticker.GetTicker(e.Exchange, e.Pair, e.Asset)
if err != nil {
if Bot.Settings.Verbose {
log.Debugf("Events: failed to get ticker. Err: %s", err)
log.Debugf(log.EventMgr, "Events: failed to get ticker. Err: %s\n", err)
}
return false
}
if t.Last == 0 {
if Bot.Settings.Verbose {
log.Debugln("Events: ticker last price is 0")
log.Debugln(log.EventMgr, "Events: ticker last price is 0")
}
return false
}
@@ -196,7 +196,7 @@ func (e *Event) processOrderbook() bool {
ob, err := orderbook.Get(e.Exchange, e.Pair, e.Asset)
if err != nil {
if Bot.Settings.Verbose {
log.Debugf("Events: Failed to get orderbook. Err: %s", err)
log.Debugf(log.EventMgr, "Events: Failed to get orderbook. Err: %s\n", err)
}
return false
}
@@ -208,7 +208,7 @@ func (e *Event) processOrderbook() bool {
result := e.processCondition(subtotal, e.Condition.OrderbookAmount)
if result {
success = true
log.Debugf("Events: Bid Amount: %f Price: %v Subtotal: %v", ob.Bids[x].Amount, ob.Bids[x].Price, subtotal)
log.Debugf(log.EventMgr, "Events: Bid Amount: %f Price: %v Subtotal: %v\n", ob.Bids[x].Amount, ob.Bids[x].Price, subtotal)
}
}
}
@@ -219,7 +219,7 @@ func (e *Event) processOrderbook() bool {
result := e.processCondition(subtotal, e.Condition.OrderbookAmount)
if result {
success = true
log.Debugf("Events: Ask Amount: %f Price: %v Subtotal: %v", ob.Asks[x].Amount, ob.Asks[x].Price, subtotal)
log.Debugf(log.EventMgr, "Events: Ask Amount: %f Price: %v Subtotal: %v\n", ob.Asks[x].Amount, ob.Asks[x].Price, subtotal)
}
}
}
@@ -281,7 +281,7 @@ func IsValidEvent(exchange, item string, condition EventConditionParams, action
// EventManger is the overarching routine that will iterate through the Events
// chain
func EventManger() {
log.Debugf("EventManager started. SleepDelay: %v", EventSleepDelay.String())
log.Debugf(log.EventMgr, "EventManager started. SleepDelay: %v\n", EventSleepDelay.String())
for {
total, executed := GetEventCounter()
@@ -289,7 +289,7 @@ func EventManger() {
for _, event := range Events {
if !event.Executed {
if Bot.Settings.Verbose {
log.Debugf("Events: Processing event %s.", event.String())
log.Debugf(log.EventMgr, "Events: Processing event %s.\n", event.String())
}
success := event.CheckEventCondition()
if success {
@@ -297,7 +297,7 @@ func EventManger() {
"Events: ID: %d triggered on %s successfully [%v]\n", event.ID,
event.Exchange, event.String(),
)
log.Info(msg)
log.Infoln(log.EventMgr, msg)
Bot.CommsManager.PushEvent(base.Event{Type: "event", Message: msg})
event.Executed = true
}

12
engine/exchange.go
View File

@@ -83,7 +83,7 @@ func ReloadExchange(name string) error {
e := GetExchangeByName(name)
e.Setup(exchCfg)
log.Debugf("%s exchange reloaded successfully.\n", name)
log.Debugf(log.ExchangeSys, "%s exchange reloaded successfully.\n", name)
return nil
}
@@ -275,13 +275,13 @@ func SetupExchanges() {
if CheckExchangeExists(exch.Name) {
e := GetExchangeByName(exch.Name)
if e == nil {
log.Errorf("%s", ErrExchangeNotFound)
log.Errorln(log.ExchangeSys, ErrExchangeNotFound)
continue
}
err := ReloadExchange(exch.Name)
if err != nil {
log.Errorf("ReloadExchange %s failed: %s", exch.Name, err)
log.Errorf(log.ExchangeSys, "ReloadExchange %s failed: %s\n", exch.Name, err)
continue
}
@@ -293,15 +293,15 @@ func SetupExchanges() {
}
if !exch.Enabled && !Bot.Settings.EnableAllExchanges {
log.Debugf("%s: Exchange support: Disabled", exch.Name)
log.Debugf(log.ExchangeSys, "%s: Exchange support: Disabled\n", exch.Name)
continue
}
err := LoadExchange(exch.Name, true, &wg)
if err != nil {
log.Errorf("LoadExchange %s failed: %s", exch.Name, err)
log.Errorf(log.ExchangeSys, "LoadExchange %s failed: %s\n", exch.Name, err)
continue
}
log.Debugf(
log.Debugf(log.ExchangeSys,
"%s: Exchange support: Enabled (Authenticated API support: %s - Verbose mode: %s).\n",
exch.Name,
common.IsEnabled(exch.API.AuthenticatedSupport),

24
engine/helpers.go
View File

@@ -119,7 +119,7 @@ func GetExchangeOTPs() (map[string]string, error) {
exchName := Bot.Config.Exchanges[x].Name
o, err := totp.GenerateCode(otpSecret, time.Now())
if err != nil {
log.Errorf("Unable to generate OTP code for exchange %s. Err: %s",
log.Errorf(log.Global, "Unable to generate OTP code for exchange %s. Err: %s\n",
exchName, err)
continue
}
@@ -541,7 +541,7 @@ func SeedExchangeAccountInfo(data []exchange.AccountInfo) {
continue
}
log.Debugf("Portfolio: Adding new exchange address: %s, %s, %f, %s\n",
log.Debugf(log.PortfolioMgr, "Portfolio: Adding new exchange address: %s, %s, %f, %s\n",
exchangeName,
currencyName,
total,
@@ -556,7 +556,7 @@ func SeedExchangeAccountInfo(data []exchange.AccountInfo) {
} else {
if total <= 0 {
log.Debugf("Portfolio: Removing %s %s entry.\n",
log.Debugf(log.PortfolioMgr, "Portfolio: Removing %s %s entry.\n",
exchangeName,
currencyName)
@@ -571,7 +571,7 @@ func SeedExchangeAccountInfo(data []exchange.AccountInfo) {
}
if balance != total {
log.Debugf("Portfolio: Updating %s %s entry with balance %f.\n",
log.Debugf(log.PortfolioMgr, "Portfolio: Updating %s %s entry with balance %f.\n",
exchangeName,
currencyName,
total)
@@ -668,14 +668,14 @@ func GetExchangeCryptocurrencyDepositAddresses() map[string]map[string]string {
exchName := Bot.Exchanges[x].GetName()
if !Bot.Exchanges[x].GetAuthenticatedAPISupport(exchange.RestAuthentication) {
if Bot.Settings.Verbose {
log.Debugf("GetExchangeCryptocurrencyDepositAddresses: Skippping %s due to disabled authenticated API support.", exchName)
log.Debugf(log.ExchangeSys, "GetExchangeCryptocurrencyDepositAddresses: Skippping %s due to disabled authenticated API support.\n", exchName)
}
continue
}
cryptoCurrencies, err := GetCryptocurrenciesByExchange(exchName, true, true, asset.Spot)
if err != nil {
log.Debugf("%s failed to get cryptocurrency deposit addresses. Err: %s", exchName, err)
log.Debugf(log.ExchangeSys, "%s failed to get cryptocurrency deposit addresses. Err: %s\n", exchName, err)
continue
}
@@ -684,7 +684,7 @@ func GetExchangeCryptocurrencyDepositAddresses() map[string]map[string]string {
cryptocurrency := cryptoCurrencies[y]
depositAddr, err := Bot.Exchanges[x].GetDepositAddress(currency.NewCode(cryptocurrency), "")
if err != nil {
log.Debugf("%s failed to get cryptocurrency deposit addresses. Err: %s", exchName, err)
log.Errorf(log.Global, "%s failed to get cryptocurrency deposit addresses. Err: %s\n", exchName, err)
continue
}
cryptoAddr[cryptocurrency] = depositAddr
@@ -748,7 +748,7 @@ func GetAllActiveTickers() []EnabledExchangeCurrencies {
for z := range currencies {
tp, err := exch.FetchTicker(currencies[z], assets[y])
if err != nil {
log.Debugf("Exchange %s failed to retrieve %s ticker. Err: %s", exchName,
log.Errorf(log.ExchangeSys, "Exchange %s failed to retrieve %s ticker. Err: %s\n", exchName,
currencies[z].String(),
err)
continue
@@ -768,13 +768,13 @@ func GetAllEnabledExchangeAccountInfo() AllEnabledExchangeAccounts {
if individualBot != nil && individualBot.IsEnabled() {
if !individualBot.GetAuthenticatedAPISupport(exchange.RestAuthentication) {
if Bot.Settings.Verbose {
log.Debugf("GetAllEnabledExchangeAccountInfo: Skippping %s due to disabled authenticated API support.", individualBot.GetName())
log.Debugf(log.ExchangeSys, "GetAllEnabledExchangeAccountInfo: Skippping %s due to disabled authenticated API support.\n", individualBot.GetName())
}
continue
}
individualExchange, err := individualBot.GetAccountInfo()
if err != nil {
log.Debugf("Error encountered retrieving exchange account info for %s. Error %s",
log.Errorf(log.ExchangeSys, "Error encountered retrieving exchange account info for %s. Error %s\n",
individualBot.GetName(), err)
continue
}
@@ -795,7 +795,7 @@ func checkCerts() error {
return genCert(targetDir)
}
log.Debugf("gRPC TLS certs directory already exists, will use them.")
log.Debugln(log.Global, "gRPC TLS certs directory already exists, will use them.")
return nil
}
@@ -875,6 +875,6 @@ func genCert(targetDir string) error {
return fmt.Errorf("failed to write cert.pem file %s", err)
}
log.Debugf("TLS key.pem and cert.pem files written to %s", targetDir)
log.Debugf(log.Global, "TLS key.pem and cert.pem files written to %s\n", targetDir)
return nil
}

28
engine/orders.go
View File

@@ -62,7 +62,7 @@ func (o *orderManager) Start() error {
return errors.New("order manager already started")
}
log.Debugln("Order manager starting...")
log.Debugln(log.OrderBook, "Order manager starting...")
o.shutdown = make(chan struct{})
o.orderStore.Orders = make(map[string][]exchange.OrderDetail)
@@ -82,23 +82,23 @@ func (o *orderManager) Stop() error {
atomic.CompareAndSwapInt32(&o.started, 1, 0)
}()
log.Debugln("Order manager shutting down...")
log.Debugln(log.OrderBook, "Order manager shutting down...")
close(o.shutdown)
return nil
}
func (o *orderManager) gracefulShutdown() {
if o.cfg.CancelOrdersOnShutdown {
log.Debug("Order manager: Cancelling any open orders...")
log.Debugln(log.OrderMgr, "Order manager: Cancelling any open orders...")
orders := o.orderStore.Get()
if orders == nil {
return
}
for k, v := range orders {
log.Debugf("Order manager: Cancelling order(s) for exchange %s.", k)
log.Debugf(log.OrderMgr, "Order manager: Cancelling order(s) for exchange %s.\n", k)
for y := range v {
log.Debugf("order manager: Cancelling order ID %v [%v]",
log.Debugf(log.OrderMgr, "order manager: Cancelling order ID %v [%v]",
v[y].ID, v[y])
err := o.Cancel(k, &exchange.OrderCancellation{
OrderID: v[y].ID,
@@ -106,7 +106,7 @@ func (o *orderManager) gracefulShutdown() {
if err != nil {
msg := fmt.Sprintf("Order manager: Exchange %s unable to cancel order ID=%v. Err: %s",
k, v[y].ID, err)
log.Debugln(msg)
log.Debugln(log.OrderBook, msg)
Bot.CommsManager.PushEvent(base.Event{
Type: "order",
Message: msg,
@@ -116,7 +116,7 @@ func (o *orderManager) gracefulShutdown() {
msg := fmt.Sprintf("Order manager: Exchange %s order ID=%v cancelled.",
k, v[y].ID)
log.Debugln(msg)
log.Debugln(log.OrderBook, msg)
Bot.CommsManager.PushEvent(base.Event{
Type: "order",
Message: msg,
@@ -127,11 +127,11 @@ func (o *orderManager) gracefulShutdown() {
}
func (o *orderManager) run() {
log.Debugln("Order manager started.")
log.Debugln(log.OrderBook, "Order manager started.")
tick := time.NewTicker(OrderManagerDelay)
Bot.ServicesWG.Add(1)
defer func() {
log.Debugf("Order manager shutdown.")
log.Debugln(log.OrderMgr, "Order manager shutdown.")
tick.Stop()
Bot.ServicesWG.Done()
}()
@@ -213,7 +213,7 @@ func (o *orderManager) Submit(exchName string, order *exchange.OrderSubmission)
id, err := common.GetV4UUID()
if err != nil {
log.Warnf("Order manager: Unable to generate UUID. Err: %s", err)
log.Warnf(log.OrderMgr, "Order manager: Unable to generate UUID. Err: %s\n", err)
}
result, err := exch.SubmitOrder(order)
@@ -227,7 +227,7 @@ func (o *orderManager) Submit(exchName string, order *exchange.OrderSubmission)
msg := fmt.Sprintf("Order manager: Exchange %s submitted order ID=%v [Ours: %v] pair=%v price=%v amount=%v side=%v type=%v.",
exchName, result.OrderID, id.String(), order.Pair, order.Price, order.Amount, order.OrderSide, order.OrderType)
log.Debugln(msg)
log.Debugln(log.OrderMgr, msg)
Bot.CommsManager.PushEvent(base.Event{
Type: "order",
Message: msg,
@@ -244,7 +244,7 @@ func (o *orderManager) Submit(exchName string, order *exchange.OrderSubmission)
func (o *orderManager) processOrders() {
authExchanges := GetAuthAPISupportedExchanges()
for x := range authExchanges {
log.Debugf("Order manager: Procesing orders for exchange %v.", authExchanges[x])
log.Debugf(log.OrderMgr, "Order manager: Procesing orders for exchange %v.\n", authExchanges[x])
exch := GetExchangeByName(authExchanges[x])
req := exchange.GetOrdersRequest{
OrderSide: exchange.AnyOrderSide,
@@ -252,7 +252,7 @@ func (o *orderManager) processOrders() {
}
result, err := exch.GetActiveOrders(&req)
if err != nil {
log.Debugf("Order manager: Unable to get active orders: %s", err)
log.Warnf(log.OrderMgr, "Order manager: Unable to get active orders: %s\n", err)
continue
}
@@ -262,7 +262,7 @@ func (o *orderManager) processOrders() {
if result != ErrOrdersAlreadyExists {
msg := fmt.Sprintf("Order manager: Exchange %s added order ID=%v pair=%v price=%v amount=%v side=%v type=%v.",
order.Exchange, order.ID, order.CurrencyPair, order.Price, order.Amount, order.OrderSide, order.OrderType)
log.Debug(msg)
log.Debugf(log.OrderMgr, "%v\n", msg)
Bot.CommsManager.PushEvent(base.Event{
Type: "order",
Message: msg,

10
engine/portfolio.go
View File

@@ -29,7 +29,7 @@ func (p *portfolioManager) Start() error {
return errors.New("portfolio manager already started")
}
log.Debugln("Portfolio manager starting...")
log.Debugln(log.PortfolioMgr, "Portfolio manager starting...")
Bot.Portfolio = &portfolio.Portfolio
Bot.Portfolio.Seed(Bot.Config.Portfolio)
p.shutdown = make(chan struct{})
@@ -41,13 +41,13 @@ func (p *portfolioManager) Stop() error {
return errors.New("portfolio manager is already stopped")
}
log.Debugln("Portfolio manager shutting down...")
log.Debugln(log.PortfolioMgr, "Portfolio manager shutting down...")
close(p.shutdown)
return nil
}
func (p *portfolioManager) run() {
log.Debugln("Portfolio manager started.")
log.Debugln(log.PortfolioMgr, "Portfolio manager started.")
Bot.ServicesWG.Add(1)
tick := time.NewTicker(PortfolioSleepDelay)
defer func() {
@@ -55,7 +55,7 @@ func (p *portfolioManager) run() {
atomic.CompareAndSwapInt32(&p.started, 1, 0)
tick.Stop()
Bot.ServicesWG.Done()
log.Debugf("Portfolio manager shutdown.")
log.Debugf(log.PortfolioMgr, "Portfolio manager shutdown.")
}()
for {
@@ -75,7 +75,7 @@ func (p *portfolioManager) processPortfolio() {
for key, value := range data {
success := pf.UpdatePortfolio(value, key)
if success {
log.Debugf(
log.Debugf(log.PortfolioMgr,
"Portfolio manager: Successfully updated address balance for %s address(es) %s\n",
key, value,
)

18
engine/restful_router.go
View File

@@ -19,7 +19,7 @@ func RESTLogger(inner http.Handler, name string) http.Handler {
start := time.Now()
inner.ServeHTTP(w, r)
log.Debugf(
log.Debugf(log.RESTSys,
"%s\t%s\t%s\t%s",
r.Method,
r.RequestURI,
@@ -32,20 +32,24 @@ func RESTLogger(inner http.Handler, name string) http.Handler {
// StartRESTServer starts a REST server
func StartRESTServer() {
listenAddr := Bot.Config.RemoteControl.DeprecatedRPC.ListenAddress
log.Debugf("Deprecated RPC server support enabled. Listen URL: http://%s:%d\n", common.ExtractHost(listenAddr), common.ExtractPort(listenAddr))
log.Debugf(log.RESTSys,
"Deprecated RPC server support enabled. Listen URL: http://%s:%d\n",
common.ExtractHost(listenAddr), common.ExtractPort(listenAddr))
err := http.ListenAndServe(listenAddr, newRouter(true))
if err != nil {
log.Errorf("Failed to start deprecated RPC server. Err: %s", err)
log.Errorf(log.RESTSys, "Failed to start deprecated RPC server. Err: %s", err)
}
}
// StartWebsocketServer starts a Websocket server
func StartWebsocketServer() {
listenAddr := Bot.Config.RemoteControl.WebsocketRPC.ListenAddress
log.Debugf("Websocket RPC support enabled. Listen URL: ws://%s:%d/ws\n", common.ExtractHost(listenAddr), common.ExtractPort(listenAddr))
log.Debugf(log.RESTSys,
"Websocket RPC support enabled. Listen URL: ws://%s:%d/ws\n",
common.ExtractHost(listenAddr), common.ExtractPort(listenAddr))
err := http.ListenAndServe(listenAddr, newRouter(false))
if err != nil {
log.Errorf("Failed to start websocket RPC server. Err: %s", err)
log.Errorf(log.RESTSys, "Failed to start websocket RPC server. Err: %s", err)
}
}
@@ -81,7 +85,9 @@ func newRouter(isREST bool) *mux.Router {
}
if Bot.Config.Profiler.Enabled {
log.Debugf("HTTP Go performance profiler (pprof) endpoint enabled: http://%s:%d/debug", common.ExtractHost(listenAddr),
log.Debugf(log.RESTSys,
"HTTP Go performance profiler (pprof) endpoint enabled: http://%s:%d/debug\n",
common.ExtractHost(listenAddr),
common.ExtractPort(listenAddr))
router.PathPrefix("/debug").Handler(http.DefaultServeMux)
}

5
engine/restful_server.go
View File

@@ -18,7 +18,7 @@ func RESTfulJSONResponse(w http.ResponseWriter, response interface{}) error {
// RESTfulError prints the REST method and error
func RESTfulError(method string, err error) {
log.Errorf("RESTful %s: server failed to send JSON response. Error %s",
log.Errorf(log.RESTSys, "RESTful %s: server failed to send JSON response. Error %s\n",
method, err)
}
@@ -74,7 +74,8 @@ func GetAllActiveOrderbooks() []EnabledExchangeOrderbooks {
for z := range currencies {
ob, err := exch.FetchOrderbook(currencies[z], assets[y])
if err != nil {
log.Errorf("Exchange %s failed to retrieve %s orderbook. Err: %s", exchName,
log.Errorf(log.RESTSys,
"Exchange %s failed to retrieve %s orderbook. Err: %s\n", exchName,
currencies[z].String(),
err)
continue

63
engine/routines.go
View File

@@ -20,7 +20,7 @@ import (
func printCurrencyFormat(price float64) string {
displaySymbol, err := currency.GetSymbolByCurrencyName(Bot.Config.Currency.FiatDisplayCurrency)
if err != nil {
log.Errorf("Failed to get display symbol: %s", err)
log.Errorf(log.Global, "Failed to get display symbol: %s\n", err)
}
return fmt.Sprintf("%s%.8f", displaySymbol, price)
@@ -32,17 +32,17 @@ func printConvertCurrencyFormat(origCurrency currency.Code, origPrice float64) s
origCurrency,
displayCurrency)
if err != nil {
log.Errorf("Failed to convert currency: %s", err)
log.Errorf(log.Global, "Failed to convert currency: %s\n", err)
}
displaySymbol, err := currency.GetSymbolByCurrencyName(displayCurrency)
if err != nil {
log.Errorf("Failed to get display symbol: %s", err)
log.Errorf(log.Global, "Failed to get display symbol: %s\n", err)
}
origSymbol, err := currency.GetSymbolByCurrencyName(origCurrency)
if err != nil {
log.Errorf("Failed to get original currency symbol for %s: %s",
log.Errorf(log.Global, "Failed to get original currency symbol for %s: %s\n",
origCurrency,
err)
}
@@ -59,7 +59,7 @@ func printConvertCurrencyFormat(origCurrency currency.Code, origPrice float64) s
func printTickerSummary(result *ticker.Price, p currency.Pair, assetType asset.Item, exchangeName string, err error) {
if err != nil {
log.Errorf("Failed to get %s %s ticker. Error: %s",
log.Errorf(log.Ticker, "Failed to get %s %s ticker. Error: %s\n",
p.String(),
exchangeName,
err)
@@ -70,7 +70,7 @@ func printTickerSummary(result *ticker.Price, p currency.Pair, assetType asset.I
if p.Quote.IsFiatCurrency() &&
p.Quote != Bot.Config.Currency.FiatDisplayCurrency {
origCurrency := p.Quote.Upper()
log.Infof("%s %s %s: TICKER: Last %s Ask %s Bid %s High %s Low %s Volume %.8f",
log.Infof(log.Ticker, "%s %s %s: TICKER: Last %s Ask %s Bid %s High %s Low %s Volume %.8f\n",
exchangeName,
FormatCurrency(p).String(),
assetType,
@@ -83,7 +83,7 @@ func printTickerSummary(result *ticker.Price, p currency.Pair, assetType asset.I
} else {
if p.Quote.IsFiatCurrency() &&
p.Quote == Bot.Config.Currency.FiatDisplayCurrency {
log.Infof("%s %s %s: TICKER: Last %s Ask %s Bid %s High %s Low %s Volume %.8f",
log.Infof(log.Ticker, "%s %s %s: TICKER: Last %s Ask %s Bid %s High %s Low %s Volume %.8f\n",
exchangeName,
FormatCurrency(p).String(),
assetType,
@@ -94,7 +94,7 @@ func printTickerSummary(result *ticker.Price, p currency.Pair, assetType asset.I
printCurrencyFormat(result.Low),
result.Volume)
} else {
log.Infof("%s %s %s: TICKER: Last %.8f Ask %.8f Bid %.8f High %.8f Low %.8f Volume %.8f",
log.Infof(log.Ticker, "%s %s %s: TICKER: Last %.8f Ask %.8f Bid %.8f High %.8f Low %.8f Volume %.8f\n",
exchangeName,
FormatCurrency(p).String(),
assetType,
@@ -110,7 +110,7 @@ func printTickerSummary(result *ticker.Price, p currency.Pair, assetType asset.I
func printOrderbookSummary(result *orderbook.Base, p currency.Pair, assetType asset.Item, exchangeName string, err error) {
if err != nil {
log.Errorf("Failed to get %s %s orderbook of type %s. Error: %s",
log.Errorf(log.OrderBook, "Failed to get %s %s orderbook of type %s. Error: %s\n",
p,
exchangeName,
assetType,
@@ -124,7 +124,7 @@ func printOrderbookSummary(result *orderbook.Base, p currency.Pair, assetType as
if p.Quote.IsFiatCurrency() &&
p.Quote != Bot.Config.Currency.FiatDisplayCurrency {
origCurrency := p.Quote.Upper()
log.Infof("%s %s %s: ORDERBOOK: Bids len: %d Amount: %f %s. Total value: %s Asks len: %d Amount: %f %s. Total value: %s",
log.Infof(log.OrderBook, "%s %s %s: ORDERBOOK: Bids len: %d Amount: %f %s. Total value: %s Asks len: %d Amount: %f %s. Total value: %s\n",
exchangeName,
FormatCurrency(p).String(),
assetType,
@@ -140,7 +140,7 @@ func printOrderbookSummary(result *orderbook.Base, p currency.Pair, assetType as
} else {
if p.Quote.IsFiatCurrency() &&
p.Quote == Bot.Config.Currency.FiatDisplayCurrency {
log.Infof("%s %s %s: ORDERBOOK: Bids len: %d Amount: %f %s. Total value: %s Asks len: %d Amount: %f %s. Total value: %s",
log.Infof(log.OrderBook, "%s %s %s: ORDERBOOK: Bids len: %d Amount: %f %s. Total value: %s Asks len: %d Amount: %f %s. Total value: %s\n",
exchangeName,
FormatCurrency(p).String(),
assetType,
@@ -154,7 +154,7 @@ func printOrderbookSummary(result *orderbook.Base, p currency.Pair, assetType as
printCurrencyFormat(asksValue),
)
} else {
log.Infof("%s %s %s: ORDERBOOK: Bids len: %d Amount: %f %s. Total value: %f Asks len: %d Amount: %f %s. Total value: %f",
log.Infof(log.OrderBook, "%s %s %s: ORDERBOOK: Bids len: %d Amount: %f %s. Total value: %f Asks len: %d Amount: %f %s. Total value: %f\n",
exchangeName,
FormatCurrency(p).String(),
assetType,
@@ -180,7 +180,7 @@ func relayWebsocketEvent(result interface{}, event, assetType, exchangeName stri
}
err := BroadcastWebsocketMessage(evt)
if err != nil {
log.Errorf("Failed to broadcast websocket event %v. Error: %s",
log.Errorf(log.WebsocketMgr, "Failed to broadcast websocket event %v. Error: %s\n",
event, err)
}
}
@@ -188,7 +188,7 @@ func relayWebsocketEvent(result interface{}, event, assetType, exchangeName stri
// TickerUpdaterRoutine fetches and updates the ticker for all enabled
// currency pairs and exchanges
func TickerUpdaterRoutine() {
log.Debugf("Starting ticker updater routine.")
log.Debugln(log.Ticker, "Starting ticker updater routine.")
var wg sync.WaitGroup
for {
wg.Add(len(Bot.Exchanges))
@@ -233,7 +233,7 @@ func TickerUpdaterRoutine() {
}(x, &wg)
}
wg.Wait()
log.Debugln("All enabled currency tickers fetched.")
log.Debugln(log.Ticker, "All enabled currency tickers fetched.")
time.Sleep(time.Second * 10)
}
}
@@ -241,7 +241,7 @@ func TickerUpdaterRoutine() {
// OrderbookUpdaterRoutine fetches and updates the orderbooks for all enabled
// currency pairs and exchanges
func OrderbookUpdaterRoutine() {
log.Debugln("Starting orderbook updater routine.")
log.Debugln(log.OrderBook, "Starting orderbook updater routine.")
var wg sync.WaitGroup
for {
wg.Add(len(Bot.Exchanges))
@@ -275,7 +275,7 @@ func OrderbookUpdaterRoutine() {
}(x, &wg)
}
wg.Wait()
log.Debugln("All enabled currency orderbooks fetched.")
log.Debugln(log.OrderBook, "All enabled currency orderbooks fetched.")
time.Sleep(time.Second * 10)
}
}
@@ -283,14 +283,14 @@ func OrderbookUpdaterRoutine() {
// WebsocketRoutine Initial routine management system for websocket
func WebsocketRoutine() {
if Bot.Settings.Verbose {
log.Debugln("Connecting exchange websocket services...")
log.Debugln(log.WebsocketMgr, "Connecting exchange websocket services...")
}
for i := range Bot.Exchanges {
go func(i int) {
if Bot.Exchanges[i].SupportsWebsocket() {
if Bot.Settings.Verbose {
log.Debugf("Exchange %s websocket support: Yes Enabled: %v", Bot.Exchanges[i].GetName(),
log.Debugf(log.WebsocketMgr, "Exchange %s websocket support: Yes Enabled: %v\n", Bot.Exchanges[i].GetName(),
common.IsEnabled(Bot.Exchanges[i].IsWebsocketEnabled()))
}
@@ -304,11 +304,11 @@ func WebsocketRoutine() {
err = ws.Connect()
if err != nil {
log.Println(err)
log.Errorf(log.WebsocketMgr, "%v\n", err)
}
}
} else if Bot.Settings.Verbose {
log.Debugf("Exchange %s websocket support: No", Bot.Exchanges[i].GetName())
log.Debugf(log.WebsocketMgr, "Exchange %s websocket support: No\n", Bot.Exchanges[i].GetName())
}
}(i)
}
@@ -322,7 +322,7 @@ var wg sync.WaitGroup
func Websocketshutdown(ws *exchange.Websocket) error {
err := ws.Shutdown() // shutdown routines on the exchange
if err != nil {
log.Errorf("routines.go error - failed to shutdown %s", err)
log.Errorf(log.WebsocketMgr, "routines.go error - failed to shutdown %s\n", err)
}
timer := time.NewTimer(5 * time.Second)
@@ -356,12 +356,12 @@ func streamDiversion(ws *exchange.Websocket) {
case <-ws.Connected:
if Bot.Settings.Verbose {
log.Debugf("exchange %s websocket feed connected", ws.GetName())
log.Debugf(log.WebsocketMgr, "exchange %s websocket feed connected\n", ws.GetName())
}
case <-ws.Disconnected:
if Bot.Settings.Verbose {
log.Debugf("exchange %s websocket feed disconnected, switching to REST functionality",
log.Debugf(log.WebsocketMgr, "exchange %s websocket feed disconnected, switching to REST functionality\n",
ws.GetName())
}
}
@@ -387,12 +387,12 @@ func WebsocketDataHandler(ws *exchange.Websocket) {
switch d {
case exchange.WebsocketNotEnabled:
if Bot.Settings.Verbose {
log.Warnf("routines.go warning - exchange %s weboscket not enabled",
log.Warnf(log.WebsocketMgr, "routines.go warning - exchange %s weboscket not enabled\n",
ws.GetName())
}
default:
log.Infof(d)
log.Info(log.WebsocketMgr, d)
}
case error:
@@ -401,7 +401,7 @@ func WebsocketDataHandler(ws *exchange.Websocket) {
go ws.WebsocketReset()
continue
default:
log.Errorf("routines.go exchange %s websocket error - %s", ws.GetName(), data)
log.Errorf(log.WebsocketMgr, "routines.go exchange %s websocket error - %s", ws.GetName(), data)
}
case exchange.TradeData:
@@ -433,7 +433,7 @@ func WebsocketDataHandler(ws *exchange.Websocket) {
case exchange.KlineData:
// Kline data
if Bot.Settings.Verbose {
log.Infoln("Websocket Kline Updated: ", d)
log.Infof(log.WebsocketMgr, "Websocket Kline Updated: %v\n", d)
}
case exchange.WebsocketOrderbookUpdate:
// Orderbook data
@@ -443,10 +443,13 @@ func WebsocketDataHandler(ws *exchange.Websocket) {
result.Pair, result.Asset, SyncItemOrderbook, nil)
}
// TO-DO: printOrderbookSummary
//nolint:gocritic log.Infof("Websocket %s %s orderbook updated", ws.GetName(), result.Pair.Pair().String())
//nolint:gocritic
if Bot.Settings.Verbose {
log.Infof(log.WebsocketMgr, "Websocket %s %s orderbook updated\n", ws.GetName(), result.Pair.String())
}
default:
if Bot.Settings.Verbose {
log.Warnf("Websocket Unknown type: %s", d)
log.Warnf(log.WebsocketMgr, "Websocket Unknown type: %s\n", d)
}
}
}

52
engine/rpcserver.go
View File

@@ -64,21 +64,21 @@ func authenticateClient(ctx context.Context) (context.Context, error) {
func StartRPCServer() {
err := checkCerts()
if err != nil {
log.Errorf("gRPC checkCerts failed. err: %s", err)
log.Errorf(log.GRPCSys, "gRPC checkCerts failed. err: %s\n", err)
return
}
log.Debugf("gRPC server support enabled. Starting gRPC server on https://%v.", Bot.Config.RemoteControl.GRPC.ListenAddress)
log.Debugf(log.GRPCSys, "gRPC server support enabled. Starting gRPC server on https://%v.\n", Bot.Config.RemoteControl.GRPC.ListenAddress)
lis, err := net.Listen("tcp", Bot.Config.RemoteControl.GRPC.ListenAddress)
if err != nil {
log.Errorf("gRPC server failed to bind to port: %s", err)
log.Errorf(log.GRPCSys, "gRPC server failed to bind to port: %s", err)
return
}
targetDir := utils.GetTLSDir(Bot.Settings.DataDir)
creds, err := credentials.NewServerTLSFromFile(filepath.Join(targetDir, "cert.pem"), filepath.Join(targetDir, "key.pem"))
if err != nil {
log.Errorf("gRPC server could not load TLS keys: %s", err)
log.Errorf(log.GRPCSys, "gRPC server could not load TLS keys: %s\n", err)
return
}
@@ -92,12 +92,12 @@ func StartRPCServer() {
go func() {
if err := server.Serve(lis); err != nil {
log.Errorf("gRPC server failed to serve: %s", err)
log.Errorf(log.GRPCSys, "gRPC server failed to serve: %s\n", err)
return
}
}()
log.Debugf("gRPC server started!")
log.Debugln(log.GRPCSys, "gRPC server started!")
if Bot.Settings.EnableGRPCProxy {
StartRPCRESTProxy()
@@ -106,7 +106,7 @@ func StartRPCServer() {
// StartRPCRESTProxy starts a gRPC proxy
func StartRPCRESTProxy() {
log.Debugf("gRPC proxy server support enabled. Starting gRPC proxy server on http://%v.", Bot.Config.RemoteControl.GRPC.GRPCProxyListenAddress)
log.Debugf(log.GRPCSys, "gRPC proxy server support enabled. Starting gRPC proxy server on http://%v.\n", Bot.Config.RemoteControl.GRPC.GRPCProxyListenAddress)
ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
@@ -114,7 +114,7 @@ func StartRPCRESTProxy() {
targetDir := utils.GetTLSDir(Bot.Settings.DataDir)
creds, err := credentials.NewClientTLSFromFile(filepath.Join(targetDir, "cert.pem"), "")
if err != nil {
log.Errorf("Unabled to start gRPC proxy. Err: %s", err)
log.Errorf(log.GRPCSys, "Unabled to start gRPC proxy. Err: %s\n", err)
return
}
@@ -127,17 +127,17 @@ func StartRPCRESTProxy() {
}
err = gctrpc.RegisterGoCryptoTraderHandlerFromEndpoint(ctx, mux, Bot.Config.RemoteControl.GRPC.ListenAddress, opts)
if err != nil {
log.Errorf("Failed to register gRPC proxy. Err: %s", err)
log.Errorf(log.GRPCSys, "Failed to register gRPC proxy. Err: %s\n", err)
}
go func() {
if err := http.ListenAndServe(Bot.Config.RemoteControl.GRPC.GRPCProxyListenAddress, mux); err != nil {
log.Errorf("gRPC proxy failed to server: %s", err)
log.Errorf(log.GRPCSys, "gRPC proxy failed to server: %s\n", err)
return
}
}()
log.Debugf("gRPC proxy server started!")
log.Debugln(log.GRPCSys, "gRPC proxy server started!")
select {}
}
@@ -606,7 +606,7 @@ func (s *RPCServer) GetForexRates(ctx context.Context, r *gctrpc.GetForexRatesRe
func (s *RPCServer) GetOrders(ctx context.Context, r *gctrpc.GetOrdersRequest) (*gctrpc.GetOrdersResponse, error) {
exch := GetExchangeByName(r.Exchange)
if exch == nil {
log.Debugln(exch)
log.Debugln(log.GRPCSys, exch)
return nil, errors.New("exchange is not loaded/doesn't exist")
}
@@ -827,3 +827,31 @@ func (s *RPCServer) WithdrawCryptocurrencyFunds(ctx context.Context, r *gctrpc.W
func (s *RPCServer) WithdrawFiatFunds(ctx context.Context, r *gctrpc.WithdrawCurrencyRequest) (*gctrpc.WithdrawResponse, error) {
return &gctrpc.WithdrawResponse{}, common.ErrNotYetImplemented
}
func (s *RPCServer) GetLoggerDetails(ctx context.Context, r *gctrpc.GetLoggerDetailsRequest) (*gctrpc.GetLoggerDetailsResponse, error) {
levels, err := log.Level(r.Logger)
if err != nil {
return nil, err
}
return &gctrpc.GetLoggerDetailsResponse{
Info: levels.Info,
Debug: levels.Debug,
Warn: levels.Warn,
Error: levels.Error,
}, nil
}
func (s *RPCServer) SetLoggerDetails(ctx context.Context, r *gctrpc.SetLoggerDetailsRequest) (*gctrpc.GetLoggerDetailsResponse, error) {
levels, err := log.SetLevel(r.Logger, r.Level)
if err != nil {
return nil, err
}
return &gctrpc.GetLoggerDetailsResponse{
Info: levels.Info,
Debug: levels.Debug,
Warn: levels.Warn,
Error: levels.Error,
}, nil
}

62
engine/syncer.go
View File

@@ -48,12 +48,12 @@ func NewCurrencyPairSyncer(c CurrencyPairSyncerConfig) (*ExchangeCurrencyPairSyn
s.tickerBatchLastRequested = make(map[string]time.Time)
log.Debugf("Exchange currency pair syncer config:")
log.Debugf("SyncContinuously: %v", s.Cfg.SyncContinuously)
log.Debugf("SyncTicker: %v", s.Cfg.SyncTicker)
log.Debugf("SyncOrderbook: %v", s.Cfg.SyncOrderbook)
log.Debugf("SyncTrades: %v", s.Cfg.SyncTrades)
log.Debugf("NumWorkers: %v", s.Cfg.NumWorkers)
log.Debugln(log.SyncMgr, "Exchange currency pair syncer config:")
log.Debugf(log.SyncMgr, "SyncContinuously: %v\n", s.Cfg.SyncContinuously)
log.Debugf(log.SyncMgr, "SyncTicker: %v\n", s.Cfg.SyncTicker)
log.Debugf(log.SyncMgr, "SyncOrderbook: %v\n", s.Cfg.SyncOrderbook)
log.Debugf(log.SyncMgr, "SyncTrades: %v\n", s.Cfg.SyncTrades)
log.Debugf(log.SyncMgr, "NumWorkers: %v\n", s.Cfg.NumWorkers)
return &s, nil
}
@@ -92,7 +92,7 @@ func (e *ExchangeCurrencyPairSyncer) add(c *CurrencyPairSyncAgent) {
defer e.mux.Unlock()
if e.Cfg.SyncTicker {
log.Debugf("%s: Added ticker sync item %v: using websocket: %v using REST: %v", c.Exchange, c.Pair.String(),
log.Debugf(log.SyncMgr, "%s: Added ticker sync item %v: using websocket: %v using REST: %v\n", c.Exchange, c.Pair.String(),
c.Ticker.IsUsingWebsocket, c.Ticker.IsUsingREST)
if atomic.LoadInt32(&e.initSyncCompleted) != 1 {
e.initSyncWG.Add(1)
@@ -101,7 +101,7 @@ func (e *ExchangeCurrencyPairSyncer) add(c *CurrencyPairSyncAgent) {
}
if e.Cfg.SyncOrderbook {
log.Debugf("%s: Added orderbook sync item %v: using websocket: %v using REST: %v", c.Exchange, c.Pair.String(),
log.Debugf(log.SyncMgr, "%s: Added orderbook sync item %v: using websocket: %v using REST: %v\n", c.Exchange, c.Pair.String(),
c.Orderbook.IsUsingWebsocket, c.Orderbook.IsUsingREST)
if atomic.LoadInt32(&e.initSyncCompleted) != 1 {
e.initSyncWG.Add(1)
@@ -110,7 +110,7 @@ func (e *ExchangeCurrencyPairSyncer) add(c *CurrencyPairSyncAgent) {
}
if e.Cfg.SyncTrades {
log.Debugf("%s: Added trade sync item %v: using websocket: %v using REST: %v", c.Exchange, c.Pair.String(),
log.Debugf(log.SyncMgr, "%s: Added trade sync item %v: using websocket: %v using REST: %v\n", c.Exchange, c.Pair.String(),
c.Trade.IsUsingWebsocket, c.Trade.IsUsingREST)
if atomic.LoadInt32(&e.initSyncCompleted) != 1 {
e.initSyncWG.Add(1)
@@ -197,7 +197,7 @@ func (e *ExchangeCurrencyPairSyncer) update(exchangeName string, p currency.Pair
return
}
default:
log.Warnf("ExchangeCurrencyPairSyncer: unknown sync item %v", syncType)
log.Warnf(log.SyncMgr, "ExchangeCurrencyPairSyncer: unknown sync item %v\n", syncType)
return
}
@@ -218,7 +218,7 @@ func (e *ExchangeCurrencyPairSyncer) update(exchangeName string, p currency.Pair
e.CurrencyPairs[x].Ticker.HaveData = true
e.CurrencyPairs[x].Ticker.IsProcessing = false
if atomic.LoadInt32(&e.initSyncCompleted) != 1 && !origHadData {
log.Debugf("%s ticker sync complete %v [%d/%d].", exchangeName, p, removedCounter, createdCounter)
log.Debugf(log.SyncMgr, "%s ticker sync complete %v [%d/%d].\n", exchangeName, p, removedCounter, createdCounter)
removedCounter++
e.initSyncWG.Done()
}
@@ -232,7 +232,7 @@ func (e *ExchangeCurrencyPairSyncer) update(exchangeName string, p currency.Pair
e.CurrencyPairs[x].Orderbook.HaveData = true
e.CurrencyPairs[x].Orderbook.IsProcessing = false
if atomic.LoadInt32(&e.initSyncCompleted) != 1 && !origHadData {
log.Debugf("%s orderbook sync complete %v [%d/%d].", exchangeName, p, removedCounter, createdCounter)
log.Debugf(log.SyncMgr, "%s orderbook sync complete %v [%d/%d].\n", exchangeName, p, removedCounter, createdCounter)
removedCounter++
e.initSyncWG.Done()
}
@@ -246,7 +246,7 @@ func (e *ExchangeCurrencyPairSyncer) update(exchangeName string, p currency.Pair
e.CurrencyPairs[x].Trade.HaveData = true
e.CurrencyPairs[x].Trade.IsProcessing = false
if atomic.LoadInt32(&e.initSyncCompleted) != 1 && !origHadData {
log.Debugf("%s trade sync complete %v [%d/%d].", exchangeName, p, removedCounter, createdCounter)
log.Debugf(log.SyncMgr, "%s trade sync complete %v [%d/%d].\n", exchangeName, p, removedCounter, createdCounter)
removedCounter++
e.initSyncWG.Done()
}
@@ -257,7 +257,7 @@ func (e *ExchangeCurrencyPairSyncer) update(exchangeName string, p currency.Pair
func (e *ExchangeCurrencyPairSyncer) worker() {
cleanup := func() {
log.Debugf("Exchange CurrencyPairSyncer worker shutting down.")
log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer worker shutting down.")
}
defer cleanup()
@@ -277,7 +277,7 @@ func (e *ExchangeCurrencyPairSyncer) worker() {
if Bot.Exchanges[x].SupportsWebsocket() && Bot.Exchanges[x].IsWebsocketEnabled() {
ws, err := Bot.Exchanges[x].GetWebsocket()
if err != nil {
log.Debugf("%s unable to get websocket pointer. Err: %s", exchangeName, err)
log.Errorf(log.SyncMgr, "%s unable to get websocket pointer. Err: %s\n", exchangeName, err)
usingREST = true
}
@@ -329,7 +329,7 @@ func (e *ExchangeCurrencyPairSyncer) worker() {
c, err := e.get(exchangeName, p, assetTypes[y])
if err != nil {
log.Errorf("failed to get item. Err: %s", err)
log.Errorf(log.SyncMgr, "failed to get item. Err: %s\n", err)
continue
}
@@ -345,7 +345,7 @@ func (e *ExchangeCurrencyPairSyncer) worker() {
e.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemTicker, true)
c.Ticker.IsUsingWebsocket = false
c.Ticker.IsUsingREST = true
log.Warnf("%s %s: No ticker update after 10 seconds, switching from websocket to rest",
log.Warnf(log.SyncMgr, "%s %s: No ticker update after 10 seconds, switching from websocket to rest\n",
c.Exchange, c.Pair.String())
e.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemTicker, false)
}
@@ -367,14 +367,14 @@ func (e *ExchangeCurrencyPairSyncer) worker() {
if batchLastDone.IsZero() || time.Since(batchLastDone) > defaultSyncerTimeout {
e.mux.Lock()
if e.Cfg.Verbose {
log.Debugf("%s Init'ing REST ticker batching", exchangeName)
log.Debugf(log.SyncMgr, "%s Init'ing REST ticker batching\n", exchangeName)
}
result, err = Bot.Exchanges[x].UpdateTicker(c.Pair, c.AssetType)
e.tickerBatchLastRequested[exchangeName] = time.Now()
e.mux.Unlock()
} else {
if e.Cfg.Verbose {
log.Debugf("%s Using recent batching cache", exchangeName)
log.Debugf(log.OrderMgr, "%s Using recent batching cache\n", exchangeName)
}
result, err = Bot.Exchanges[x].FetchTicker(c.Pair, c.AssetType)
}
@@ -407,7 +407,7 @@ func (e *ExchangeCurrencyPairSyncer) worker() {
e.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemOrderbook, true)
c.Orderbook.IsUsingWebsocket = false
c.Orderbook.IsUsingREST = true
log.Warnf("%s %s: No orderbook update after 15 seconds, switching from websocket to rest",
log.Warnf(log.SyncMgr, "%s %s: No orderbook update after 15 seconds, switching from websocket to rest\n",
c.Exchange, c.Pair.String())
e.setProcessing(c.Exchange, c.Pair, c.AssetType, SyncItemOrderbook, false)
}
@@ -445,7 +445,7 @@ func (e *ExchangeCurrencyPairSyncer) worker() {
// Start starts an exchange currency pair syncer
func (e *ExchangeCurrencyPairSyncer) Start() {
log.Debugf("Exchange CurrencyPairSyncer started.")
log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer started.")
for x := range Bot.Exchanges {
if !Bot.Exchanges[x].IsEnabled() {
@@ -458,7 +458,7 @@ func (e *ExchangeCurrencyPairSyncer) Start() {
supportsREST := Bot.Exchanges[x].SupportsREST()
if !supportsREST && !supportsWebsocket {
log.Warnf("Loaded exchange %s does not support REST or Websocket.", exchangeName)
log.Warnf(log.SyncMgr, "Loaded exchange %s does not support REST or Websocket.\n", exchangeName)
continue
}
@@ -468,7 +468,7 @@ func (e *ExchangeCurrencyPairSyncer) Start() {
if supportsWebsocket {
ws, err := Bot.Exchanges[x].GetWebsocket()
if err != nil {
log.Errorf("%s failed to get websocket. Err: %s", exchangeName, err)
log.Errorf(log.SyncMgr, "%s failed to get websocket. Err: %s\n", exchangeName, err)
usingREST = true
}
@@ -481,7 +481,7 @@ func (e *ExchangeCurrencyPairSyncer) Start() {
err = ws.Connect()
if err != nil {
log.Errorf("%s websocket failed to connect. Err: %s", exchangeName, err)
log.Errorf(log.SyncMgr, "%s websocket failed to connect. Err: %s\n", exchangeName, err)
usingREST = true
} else {
usingWebsocket = true
@@ -529,21 +529,21 @@ func (e *ExchangeCurrencyPairSyncer) Start() {
}
if atomic.CompareAndSwapInt32(&e.initSyncStarted, 0, 1) {
log.Debugln("Exchange CurrencyPairSyncer initial sync started.")
log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer initial sync started.")
e.initSyncStartTime = time.Now()
log.Debugln(createdCounter)
log.Debugln(removedCounter)
log.Debugln(log.SyncMgr, createdCounter)
log.Debugln(log.SyncMgr, removedCounter)
}
go func() {
e.initSyncWG.Wait()
if atomic.CompareAndSwapInt32(&e.initSyncCompleted, 0, 1) {
log.Debugf("Exchange CurrencyPairSyncer initial sync is complete.")
log.Debugf(log.SyncMgr, "Exchange CurrencyPairSyncer initial sync is complete.\n")
completedTime := time.Now()
log.Debugf("Exchange CurrencyPairSyncer initiial sync took %v [%v sync items].", completedTime.Sub(e.initSyncStartTime), createdCounter)
log.Debugf(log.SyncMgr, "Exchange CurrencyPairSyncer initiial sync took %v [%v sync items].\n", completedTime.Sub(e.initSyncStartTime), createdCounter)
if !e.Cfg.SyncContinuously {
log.Debugf("Exchange CurrencyPairSyncer stopping.")
log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer stopping.")
e.Stop()
Bot.Stop()
return
@@ -564,6 +564,6 @@ func (e *ExchangeCurrencyPairSyncer) Start() {
func (e *ExchangeCurrencyPairSyncer) Stop() {
stopped := atomic.CompareAndSwapInt32(&e.shutdown, 0, 1)
if stopped {
log.Debugf("Exchange CurrencyPairSyncer stopped.")
log.Debugln(log.SyncMgr, "Exchange CurrencyPairSyncer stopped.")
}
}

3
engine/syncer_test.go
View File

@@ -5,7 +5,6 @@ import (
"time"
"github.com/thrasher-/gocryptotrader/config"
log "github.com/thrasher-/gocryptotrader/logger"
)
func TestNewCurrencyPairSyncer(t *testing.T) {
@@ -27,7 +26,7 @@ func TestNewCurrencyPairSyncer(t *testing.T) {
SetupExchanges()
if err != nil {
log.Printf("failed to start exchange syncer")
t.Log("failed to start exchange syncer")
}
Bot.ExchangeCurrencyPairManager, err = NewCurrencyPairSyncer(CurrencyPairSyncerConfig{

14
engine/timekeeper.go
View File

@@ -42,7 +42,7 @@ func (n *ntpManager) Start() (err error) {
}
}()
log.Debugln("NTP manager starting...")
log.Debugln(log.TimeMgr, "NTP manager starting...")
if Bot.Config.NTPClient.Level == 0 {
// Initial NTP check (prompts user on how we should proceed)
n.inititalCheck = true
@@ -55,7 +55,7 @@ func (n *ntpManager) Start() (err error) {
case nil:
break
case errNTPDisabled:
log.Debugf("NTP manager: User disabled NTP prompts. Exiting.")
log.Debugln(log.TimeMgr, "NTP manager: User disabled NTP prompts. Exiting.")
disable = true
err = nil
return
@@ -68,7 +68,7 @@ func (n *ntpManager) Start() (err error) {
}
n.shutdown = make(chan struct{})
go n.run()
log.Debugln("NTP manager started.")
log.Debugln(log.TimeMgr, "NTP manager started.")
return nil
}
@@ -82,7 +82,7 @@ func (n *ntpManager) Stop() error {
}
close(n.shutdown)
log.Debugln("NTP manager shutting down...")
log.Debugln(log.TimeMgr, "NTP manager shutting down...")
return nil
}
@@ -92,7 +92,7 @@ func (n *ntpManager) run() {
t.Stop()
atomic.CompareAndSwapInt32(&n.stopped, 1, 0)
atomic.CompareAndSwapInt32(&n.started, 1, 0)
log.Debugln("NTP manager shutdown.")
log.Debugln(log.TimeMgr, "NTP manager shutdown.")
}()
for {
@@ -123,14 +123,14 @@ func (n *ntpManager) processTime() error {
configNTPTime := *Bot.Config.NTPClient.AllowedDifference
configNTPNegativeTime := (*Bot.Config.NTPClient.AllowedNegativeDifference - (*Bot.Config.NTPClient.AllowedNegativeDifference * 2))
if NTPcurrentTimeDifference > configNTPTime || NTPcurrentTimeDifference < configNTPNegativeTime {
log.Warnf("NTP manager: Time out of sync (NTP): %v | (time.Now()): %v | (Difference): %v | (Allowed): +%v / %v", NTPTime, currentTime, NTPcurrentTimeDifference, configNTPTime, configNTPNegativeTime)
log.Warnf(log.TimeMgr, "NTP manager: Time out of sync (NTP): %v | (time.Now()): %v | (Difference): %v | (Allowed): +%v / %v\n", NTPTime, currentTime, NTPcurrentTimeDifference, configNTPTime, configNTPNegativeTime)
if n.inititalCheck {
n.inititalCheck = false
disable, err := Bot.Config.DisableNTPCheck(os.Stdin)
if err != nil {
return fmt.Errorf("unable to disable NTP check: %s", err)
}
log.Info(disable)
log.Infoln(log.TimeMgr, disable)
if Bot.Config.NTPClient.Level == -1 {
return errNTPDisabled
}

45
engine/websocket.go
View File

@@ -59,7 +59,7 @@ func (h *WebsocketHub) run() {
h.Clients[client] = true
case client := <-h.Unregister:
if _, ok := h.Clients[client]; ok {
log.Debugln("websocket: disconnected client")
log.Debugln(log.WebsocketMgr, "websocket: disconnected client")
delete(h.Clients, client)
close(client.Send)
}
@@ -68,7 +68,7 @@ func (h *WebsocketHub) run() {
select {
case client.Send <- message:
default:
log.Debugln("websocket: disconnected client")
log.Debugln(log.WebsocketMgr, "websocket: disconnected client")
close(client.Send)
delete(h.Clients, client)
}
@@ -81,7 +81,7 @@ func (h *WebsocketHub) run() {
func (c *WebsocketClient) SendWebsocketMessage(evt interface{}) error {
data, err := common.JSONEncode(evt)
if err != nil {
log.Errorf("websocket: failed to send message: %s", err)
log.Errorf(log.WebsocketMgr, "websocket: failed to send message: %s\n", err)
return err
}
@@ -99,7 +99,7 @@ func (c *WebsocketClient) read() {
msgType, message, err := c.Conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
log.Errorf("websocket: client disconnected, err: %s", err)
log.Errorf(log.WebsocketMgr, "websocket: client disconnected, err: %s\n", err)
}
break
}
@@ -108,39 +108,39 @@ func (c *WebsocketClient) read() {
var evt WebsocketEvent
err := common.JSONDecode(message, &evt)
if err != nil {
log.Errorf("websocket: failed to decode JSON sent from client %s", err)
log.Errorf(log.WebsocketMgr, "websocket: failed to decode JSON sent from client %s\n", err)
continue
}
if evt.Event == "" {
log.Warnf("websocket: client sent a blank event, disconnecting")
log.Warnln(log.WebsocketMgr, "websocket: client sent a blank event, disconnecting")
continue
}
dataJSON, err := common.JSONEncode(evt.Data)
if err != nil {
log.Errorf("websocket: client sent data we couldn't JSON decode")
log.Errorln(log.WebsocketMgr, "websocket: client sent data we couldn't JSON decode")
break
}
req := strings.ToLower(evt.Event)
log.Debugf("websocket: request received: %s", req)
log.Debugf(log.WebsocketMgr, "websocket: request received: %s\n", req)
result, ok := wsHandlers[req]
if !ok {
log.Debugln("websocket: unsupported event")
log.Debugln(log.WebsocketMgr, "websocket: unsupported event")
continue
}
if result.authRequired && !c.Authenticated {
log.Warnf("Websocket: request %s failed due to unauthenticated request on an authenticated API", evt.Event)
log.Warnf(log.WebsocketMgr, "Websocket: request %s failed due to unauthenticated request on an authenticated API\n", evt.Event)
c.SendWebsocketMessage(WebsocketEventResponse{Event: evt.Event, Error: "unauthorised request on authenticated API"})
continue
}
err = result.handler(c, dataJSON)
if err != nil {
log.Errorf("websocket: request %s failed. Error %s", evt.Event, err)
log.Errorf(log.WebsocketMgr, "websocket: request %s failed. Error %s\n", evt.Event, err)
continue
}
}
@@ -156,13 +156,13 @@ func (c *WebsocketClient) write() {
case message, ok := <-c.Send:
if !ok {
c.Conn.WriteMessage(websocket.CloseMessage, []byte{})
log.Debugln("websocket: hub closed the channel")
log.Debugln(log.WebsocketMgr, "websocket: hub closed the channel")
return
}
w, err := c.Conn.NextWriter(websocket.TextMessage)
if err != nil {
log.Errorf("websocket: failed to create new io.writeCloser: %s", err)
log.Errorf(log.WebsocketMgr, "websocket: failed to create new io.writeCloser: %s\n", err)
return
}
w.Write(message)
@@ -174,7 +174,7 @@ func (c *WebsocketClient) write() {
}
if err := w.Close(); err != nil {
log.Errorf("websocket: failed to close io.WriteCloser: %s", err)
log.Errorf(log.WebsocketMgr, "websocket: failed to close io.WriteCloser: %s\n", err)
return
}
}
@@ -217,7 +217,8 @@ func WebsocketClientHandler(w http.ResponseWriter, r *http.Request) {
numClients := len(wsHub.Clients)
if numClients >= connectionLimit {
log.Warnf("websocket: client rejected due to websocket client limit reached. Number of clients %d. Limit %d.",
log.Warnf(log.WebsocketMgr,
"websocket: client rejected due to websocket client limit reached. Number of clients %d. Limit %d.\n",
numClients, connectionLimit)
w.WriteHeader(http.StatusForbidden)
return
@@ -236,13 +237,14 @@ func WebsocketClientHandler(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Error(err)
log.Error(log.WebsocketMgr, err)
return
}
client := &WebsocketClient{Hub: wsHub, Conn: conn, Send: make(chan []byte, 1024)}
client.Hub.Register <- client
log.Debugf("websocket: client connected. Connected clients: %d. Limit %d.",
log.Debugf(log.WebsocketMgr,
"websocket: client connected. Connected clients: %d. Limit %d.\n",
numClients+1, connectionLimit)
go client.read()
@@ -266,7 +268,8 @@ func wsAuth(client *WebsocketClient, data interface{}) error {
if auth.Username == Bot.Config.RemoteControl.Username && auth.Password == hashPW {
client.Authenticated = true
wsResp.Data = WebsocketResponseSuccess
log.Debugf("websocket: client authenticated successfully")
log.Debugln(log.WebsocketMgr,
"websocket: client authenticated successfully")
return client.SendWebsocketMessage(wsResp)
}
@@ -274,13 +277,15 @@ func wsAuth(client *WebsocketClient, data interface{}) error {
client.authFailures++
client.SendWebsocketMessage(wsResp)
if client.authFailures >= Bot.Config.RemoteControl.WebsocketRPC.MaxAuthFailures {
log.Debugf("websocket: disconnecting client, maximum auth failures threshold reached (failures: %d limit: %d)",
log.Debugf(log.WebsocketMgr,
"websocket: disconnecting client, maximum auth failures threshold reached (failures: %d limit: %d)\n",
client.authFailures, Bot.Config.RemoteControl.WebsocketRPC.MaxAuthFailures)
wsHub.Unregister <- client
return nil
}
log.Debugf("websocket: client sent wrong username/password (failures: %d limit: %d)",
log.Debugf(log.WebsocketMgr,
"websocket: client sent wrong username/password (failures: %d limit: %d)\n",
client.authFailures, Bot.Config.RemoteControl.WebsocketRPC.MaxAuthFailures)
return nil
}