diff --git a/be1-go/cli/cli.go b/be1-go/cli/cli.go index 27ec8d3b6d..2013f08956 100644 --- a/be1-go/cli/cli.go +++ b/be1-go/cli/cli.go @@ -8,7 +8,6 @@ import ( "github.com/fsnotify/fsnotify" "github.com/gorilla/websocket" "github.com/rs/zerolog" - "github.com/rs/zerolog/log" "github.com/urfave/cli/v2" "go.dedis.ch/kyber/v3" "golang.org/x/exp/slices" @@ -51,35 +50,10 @@ type ServerConfig struct { DatabasePath string `json:"database-path"` } -func (s *ServerConfig) newHub(l *zerolog.Logger) (oldHub.Hub, error) { - // compute the client server address if it wasn't provided - if s.ClientAddress == "" { - s.ClientAddress = fmt.Sprintf("ws://%s:%d/client", s.PublicAddress, s.ClientPort) - } - // compute the server server address if it wasn't provided - if s.ServerAddress == "" { - s.ServerAddress = fmt.Sprintf("ws://%s:%d/server", s.PublicAddress, s.ServerPort) - } - - var ownerPubKey kyber.Point = nil - err := ownerKey(s.PublicKey, &ownerPubKey) - if err != nil { - return nil, err - } - - hub, err := hub.New(s.DatabasePath, ownerPubKey, s.ClientAddress, s.ServerAddress) - - if err != nil { - return nil, err - } - - return hub, nil -} - // Serve parses the CLI arguments and spawns a hub and a websocket server for // the server func Serve(cliCtx *cli.Context) error { - poplog := logger.Logger + log := logger.Logger configFilePath := cliCtx.String("config-file") var serverConfig ServerConfig @@ -102,7 +76,7 @@ func Serve(cliCtx *cli.Context) error { } } - h, err := serverConfig.newHub(&poplog) + h, err := serverConfig.newHub(log) if err != nil { return err } @@ -111,13 +85,11 @@ func Serve(cliCtx *cli.Context) error { h.Start() // Start websocket server for clients - clientSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ClientPort, socket.ClientSocketType, - poplog.With().Str("role", "client websocket").Logger()) + clientSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ClientPort, socket.ClientSocketType, log) clientSrv.Start() // Start a websocket server for remote servers - serverSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ServerPort, socket.ServerSocketType, - poplog.With().Str("role", "server websocket").Logger()) + serverSrv := network.NewServer(h, serverConfig.PrivateAddress, serverConfig.ServerPort, socket.ServerSocketType, log) serverSrv.Start() // create wait group which waits for goroutines to finish @@ -141,7 +113,7 @@ func Serve(cliCtx *cli.Context) error { } // start watching goroutine - go watchConfigFile(watcher, configFilePath, &serverConfig.OtherServers, updatedServersChan) + go watchConfigFile(watcher, configFilePath, &serverConfig.OtherServers, updatedServersChan, log) } // map to keep track of the connection status of the servers @@ -152,7 +124,7 @@ func Serve(cliCtx *cli.Context) error { } wg.Add(1) - go serverConnectionLoop(h, wg, done, serverConfig.OtherServers, updatedServersChan, &connectedServers) + go serverConnectionLoop(h, wg, done, serverConfig.OtherServers, updatedServersChan, &connectedServers, log) // Wait for a Ctrl-C err = network.WaitAndShutdownServers(cliCtx.Context, nil, clientSrv, serverSrv) @@ -177,18 +149,38 @@ func Serve(cliCtx *cli.Context) error { select { case <-channsClosed: case <-time.After(time.Second * 10): - poplog.Error().Msg("channs didn't close after timeout, exiting") + log.Error().Msg("channs didn't close after timeout, exiting") } return nil } +func (s *ServerConfig) newHub(log zerolog.Logger) (oldHub.Hub, error) { + // compute the client server address if it wasn't provided + if s.ClientAddress == "" { + s.ClientAddress = fmt.Sprintf("ws://%s:%d/client", s.PublicAddress, s.ClientPort) + } + // compute the server server address if it wasn't provided + if s.ServerAddress == "" { + s.ServerAddress = fmt.Sprintf("ws://%s:%d/server", s.PublicAddress, s.ServerPort) + } + + var ownerPubKey kyber.Point = nil + err := ownerKey(s.PublicKey, &ownerPubKey, log) + if err != nil { + return nil, err + } + + return hub.New(s.DatabasePath, ownerPubKey, s.ClientAddress, s.ServerAddress, log) +} + // serverConnectionLoop tries to connect to the remote servers following an exponential backoff strategy // it also listens for updates in the other-servers field and tries to connect to the new servers -func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, otherServers []string, updatedServersChan chan []string, connectedServers *map[string]bool) { +func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, otherServers []string, + updatedServersChan chan []string, connectedServers *map[string]bool, log zerolog.Logger) { // first connection to the servers serversToConnect := otherServers - _ = connectToServers(h, wg, done, serversToConnect, connectedServers) + _ = connectToServers(h, wg, done, serversToConnect, connectedServers, log) // define the delay between connection retries delay := connectionRetryInitialDelay @@ -201,7 +193,7 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, case <-ticker.C: // try to connect to servers log.Info().Msgf("Trying to connect to servers: %v", serversToConnect) - err := connectToServers(h, wg, done, serversToConnect, connectedServers) + err := connectToServers(h, wg, done, serversToConnect, connectedServers, log) if err != nil { increaseDelay(&delay) ticker.Reset(delay) @@ -212,7 +204,7 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, delay = connectionRetryInitialDelay ticker.Reset(delay) serversToConnect = newServersList - _ = connectToServers(h, wg, done, serversToConnect, connectedServers) + _ = connectToServers(h, wg, done, serversToConnect, connectedServers, log) case <-done: log.Info().Msg("Stopping the server connection loop") wg.Done() @@ -223,12 +215,13 @@ func serverConnectionLoop(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, // connectToServers updates the connection status of the servers and tries to connect to the ones that are not connected // it returns an error if at least one connection fails -func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, servers []string, connectedServers *map[string]bool) error { +func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, servers []string, + connectedServers *map[string]bool, log zerolog.Logger) error { updateServersState(servers, connectedServers) var returnErr error for serverAddress, connected := range *connectedServers { if !connected { - err := connectToSocket(serverAddress, h, wg, done) + err := connectToSocket(serverAddress, h, wg, done, log) if err == nil { (*connectedServers)[serverAddress] = true } else { @@ -242,11 +235,7 @@ func connectToServers(h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, serv // connectToSocket establishes a connection to another server's server // endpoint. -func connectToSocket(address string, h oldHub.Hub, - wg *sync.WaitGroup, done chan struct{}) error { - - poplog := logger.Logger - +func connectToSocket(address string, h oldHub.Hub, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger) error { urlString := fmt.Sprintf("ws://%s/server", address) u, err := url.Parse(urlString) if err != nil { @@ -258,10 +247,10 @@ func connectToSocket(address string, h oldHub.Hub, return xerrors.Errorf("failed to dial to %s: %v", u.String(), err) } - poplog.Info().Msgf("connected to server at %s", urlString) + log.Info().Msgf("connected to server at %s", urlString) remoteSocket := socket.NewServerSocket(h.Receiver(), - h.OnSocketClose(), ws, wg, done, poplog) + h.OnSocketClose(), ws, wg, done, log) wg.Add(2) go remoteSocket.WritePump() @@ -277,7 +266,7 @@ func connectToSocket(address string, h oldHub.Hub, return nil } -func ownerKey(pk string, point *kyber.Point) error { +func ownerKey(pk string, point *kyber.Point, log zerolog.Logger) error { if pk != "" { *point = crypto.Suite.Point() // decode public key and unmarshal public key @@ -357,7 +346,8 @@ func startWithFlags(cliCtx *cli.Context) (ServerConfig, error) { // watchConfigFile watches the config file for changes, updates the other servers list in the config if necessary // and sends the updated other servers list to the updatedServersChan so that the connection to servers loop can // connect to them and update their connection status -func watchConfigFile(watcher *fsnotify.Watcher, configFilePath string, otherServersField *[]string, updatedServersChan chan []string) { +func watchConfigFile(watcher *fsnotify.Watcher, configFilePath string, otherServersField *[]string, + updatedServersChan chan []string, log zerolog.Logger) { for event := range watcher.Events { if event.Op&fsnotify.Write == fsnotify.Write { updatedConfig, err := loadConfig(configFilePath) diff --git a/be1-go/cli/cli_test.go b/be1-go/cli/cli_test.go index 52c6251a91..831aee2b53 100644 --- a/be1-go/cli/cli_test.go +++ b/be1-go/cli/cli_test.go @@ -3,6 +3,8 @@ package main import ( "encoding/json" "github.com/fsnotify/fsnotify" + "github.com/rs/zerolog" + "github.com/stretchr/testify/require" "golang.org/x/xerrors" "io" "os" @@ -14,9 +16,6 @@ import ( "sync" "testing" "time" - - "github.com/rs/zerolog" - "github.com/stretchr/testify/require" ) const ( @@ -52,7 +51,7 @@ func TestConnectToSocket(t *testing.T) { wh.Start() wg := &sync.WaitGroup{} - err = connectToSocket("localhost:9001", wh, wg, wDone) + err = connectToSocket("localhost:9001", wh, wg, wDone, log) require.NoError(t, err) err = remoteSrv.Shutdown() @@ -100,6 +99,8 @@ func TestLoadConfigFileWithInvalidAuthPort(t *testing.T) { // TestWatchConfigFile tests that a config file is watched correctly and the updated servers are received func TestWatchConfigFile(t *testing.T) { + log := zerolog.New(io.Discard) + // Load the config from the file serverConfig, err := loadConfig(validConfigWatcherPath) require.NoError(t, err) @@ -119,7 +120,7 @@ func TestWatchConfigFile(t *testing.T) { updatedServersChan := make(chan []string) // Start watching the config file - go watchConfigFile(watcher, validConfigWatcherPath, &serverConfig.OtherServers, updatedServersChan) + go watchConfigFile(watcher, validConfigWatcherPath, &serverConfig.OtherServers, updatedServersChan, log) defer func(watcher *fsnotify.Watcher) { require.NoError(t, watcher.Close()) }(watcher) diff --git a/be1-go/internal/database/sqlite/query.go b/be1-go/internal/database/sqlite/query.go index 6c0de89bd0..f488fb42b0 100644 --- a/be1-go/internal/database/sqlite/query.go +++ b/be1-go/internal/database/sqlite/query.go @@ -149,7 +149,7 @@ func (s *SQLite) CheckRumor(senderID string, rumorID int) (bool, error) { if rumorID == 0 { err := s.database.QueryRow(selectAnyRumor, senderID).Scan(&id) if err != nil && !errors.Is(err, sql.ErrNoRows) { - return false, err + return false, poperrors.NewDatabaseSelectErrorMsg(err.Error()) } else if errors.Is(err, sql.ErrNoRows) { return true, nil } @@ -158,7 +158,7 @@ func (s *SQLite) CheckRumor(senderID string, rumorID int) (bool, error) { err := s.database.QueryRow(selectLastRumor, senderID).Scan(&id) if err != nil && !errors.Is(err, sql.ErrNoRows) { - return false, err + return false, poperrors.NewDatabaseSelectErrorMsg(err.Error()) } else if errors.Is(err, sql.ErrNoRows) { return false, nil } diff --git a/be1-go/internal/database/sqlite/sqlite_init.go b/be1-go/internal/database/sqlite/sqlite_init.go index 16011ee74e..cbe2aeabc0 100644 --- a/be1-go/internal/database/sqlite/sqlite_init.go +++ b/be1-go/internal/database/sqlite/sqlite_init.go @@ -3,6 +3,7 @@ package sqlite import ( "database/sql" "encoding/base64" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" poperrors "popstellar/internal/errors" "popstellar/internal/handler/channel" @@ -14,6 +15,7 @@ var dbLock sync.RWMutex // SQLite is a wrapper around the SQLite database. type SQLite struct { database *sql.DB + log zerolog.Logger } //====================================================================================================================== @@ -21,7 +23,7 @@ type SQLite struct { //====================================================================================================================== // NewSQLite returns a new SQLite instance. -func NewSQLite(path string, foreignKeyOn bool) (SQLite, error) { +func NewSQLite(path string, foreignKeyOn bool, log zerolog.Logger) (SQLite, error) { dbLock.Lock() defer dbLock.Unlock() @@ -99,7 +101,10 @@ func NewSQLite(path string, foreignKeyOn bool) (SQLite, error) { return SQLite{}, poperrors.NewDatabaseTransactionCommitErrorMsg("%v", err) } - return SQLite{database: db}, nil + return SQLite{ + database: db, + log: log.With().Str("module", "sqlite").Logger(), + }, nil } func initRumorTables(tx *sql.Tx) error { diff --git a/be1-go/internal/database/sqlite/sqlite_test.go b/be1-go/internal/database/sqlite/sqlite_test.go index 813e136869..f0585b7b18 100644 --- a/be1-go/internal/database/sqlite/sqlite_test.go +++ b/be1-go/internal/database/sqlite/sqlite_test.go @@ -5,7 +5,9 @@ import ( "encoding/base64" "encoding/json" "fmt" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "os" "path/filepath" "popstellar/internal/crypto" @@ -82,7 +84,7 @@ func newFakeSQLite(t *testing.T) (SQLite, string, error) { require.NoError(t, err) fn := filepath.Join(dir, "test.DB") - lite, err := NewSQLite(fn, false) + lite, err := NewSQLite(fn, false, zerolog.New(io.Discard)) require.NoError(t, err) return lite, dir, nil diff --git a/be1-go/internal/errors/errors.go b/be1-go/internal/errors/errors.go index 53512870b5..79b45359f7 100644 --- a/be1-go/internal/errors/errors.go +++ b/be1-go/internal/errors/errors.go @@ -1,7 +1,9 @@ package errors import ( + "encoding/json" "fmt" + "path/filepath" "runtime" ) @@ -55,7 +57,7 @@ func (p *PopError) Error() string { func NewPopError(code int, format string, a ...interface{}) *PopError { var pcs [depthStack]uintptr - n := runtime.Callers(2, pcs[:]) + n := runtime.Callers(3, pcs[:]) stack := pcs[0:n] return &PopError{ @@ -75,14 +77,40 @@ func (p *PopError) StackTraceString() string { for { frame, ok := frames.Next() - stackTrace += fmt.Sprintf("%s\n\t%s:%d\n", frame.Function, frame.File, frame.Line) if !ok { break } + stackTrace += fmt.Sprintf("%s\n\t%s:%d\n", filepath.Base(frame.Function), filepath.Base(frame.File), frame.Line) } + return stackTrace } +type Frame struct { + Function string `json:"function"` + File string `json:"file"` + Line int `json:"line"` +} + +func (p *PopError) GetStackTraceJSON() ([]byte, error) { + frames := runtime.CallersFrames(p.stackTrace) + var stackTraceArray []Frame + + for { + frame, ok := frames.Next() + if !ok { + break + } + stackTraceArray = append(stackTraceArray, Frame{ + Function: filepath.Base(frame.Function), + File: filepath.Base(frame.File), + Line: frame.Line, + }) + } + + return json.Marshal(stackTraceArray) +} + // NewInvalidActionError returns an error with the code -1 for an invalid action func NewInvalidActionError(format string, a ...interface{}) error { return NewPopError(InvalidActionErrorCode, InvalidActionErrorMsg+format, a...) diff --git a/be1-go/internal/handler/answer/hanswer/answer.go b/be1-go/internal/handler/answer/hanswer/answer.go index 9cd7f169b2..6fa9ee9f93 100644 --- a/be1-go/internal/handler/answer/hanswer/answer.go +++ b/be1-go/internal/handler/answer/hanswer/answer.go @@ -2,12 +2,12 @@ package hanswer import ( "encoding/json" + "github.com/rs/zerolog" "math/rand" "popstellar/internal/errors" "popstellar/internal/handler/answer/manswer" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/rumor/mrumor" - "popstellar/internal/logger" "popstellar/internal/network/socket" "sort" ) @@ -39,12 +39,14 @@ type Handlers struct { type Handler struct { queries Queries handlers Handlers + log zerolog.Logger } -func New(queries Queries, handlers Handlers) *Handler { +func New(queries Queries, handlers Handlers, log zerolog.Logger) *Handler { return &Handler{ queries: queries, handlers: handlers, + log: log.With().Str("module", "answer").Logger(), } } @@ -57,7 +59,7 @@ func (h *Handler) Handle(msg []byte) error { } if answerMsg.ID == nil { - logger.Logger.Info().Msg("received an answer with a null id") + h.log.Info().Msg("received an answer with a null id") return nil } @@ -67,14 +69,14 @@ func (h *Handler) Handle(msg []byte) error { } if answerMsg.Result == nil { - logger.Logger.Info().Msg("received an error, nothing to handle") + h.log.Info().Msg("received an error, nothing to handle") // don't send any error to avoid infinite error loop as a server will // send an error to another server that will create another error return nil } if answerMsg.Result.IsEmpty() { - logger.Logger.Info().Msg("expected isn't an answer to a popquery, nothing to handle") + h.log.Info().Msg("expected isn't an answer to a popquery, nothing to handle") return nil } @@ -94,26 +96,26 @@ func (h *Handler) handleRumorAnswer(msg manswer.Answer) error { return err } - logger.Logger.Debug().Msgf("received an answer to rumor query %d", *msg.ID) + h.log.Debug().Msgf("received an answer to rumor query %d", *msg.ID) if msg.Error != nil { - logger.Logger.Debug().Msgf("received an answer error to rumor query %d", *msg.ID) + h.log.Debug().Msgf("received an answer error to rumor query %d", *msg.ID) if msg.Error.Code != errors.DuplicateResourceErrorCode { - logger.Logger.Debug().Msgf("invalid error code to rumor query %d", *msg.ID) + h.log.Debug().Msgf("invalid error code to rumor query %d", *msg.ID) return nil } stop := rand.Float64() < continueMongering if stop { - logger.Logger.Debug().Msgf("stop mongering rumor query %d", *msg.ID) + h.log.Debug().Msgf("stop mongering rumor query %d", *msg.ID) return nil } - logger.Logger.Debug().Msgf("continue mongering rumor query %d", *msg.ID) + h.log.Debug().Msgf("continue mongering rumor query %d", *msg.ID) } - logger.Logger.Debug().Msgf("sender rumor need to continue sending query %d", *msg.ID) + h.log.Debug().Msgf("sender rumor need to continue sending query %d", *msg.ID) rumor, ok := h.queries.GetRumorFromPastQuery(*msg.ID) if !ok { return errors.NewInternalServerError("rumor query %d doesn't exist", *msg.ID) @@ -140,7 +142,7 @@ func (h *Handler) handleGetMessagesByIDAnswer(msg manswer.Answer) { } err = errors.NewJsonUnmarshalError(err.Error()) - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } if len(msgsByChan[channelID]) == 0 { @@ -176,7 +178,7 @@ func (h *Handler) tryToHandleMessages(msgsByChannel map[string]map[string]mmessa continue } - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } if len(msgsByChannel[channelID]) == 0 { diff --git a/be1-go/internal/handler/answer/hanswer/answer_test.go b/be1-go/internal/handler/answer/hanswer/answer_test.go index 8faedc96f4..88414f8adc 100644 --- a/be1-go/internal/handler/answer/hanswer/answer_test.go +++ b/be1-go/internal/handler/answer/hanswer/answer_test.go @@ -45,16 +45,16 @@ func (n *nullRumorSender) SendRumor(socket socket.Socket, rumor mrumor.Rumor) { func Test_handleMessagesByChannel(t *testing.T) { - l := zerolog.New(io.Discard) + log := zerolog.New(io.Discard) - queries := state.NewQueries(&l) + queries := state.NewQueries(log) answerHandlers := Handlers{ MessageHandler: &nullMessageHandler{}, RumorSender: &nullRumorSender{}, } - handler := New(queries, answerHandlers) + handler := New(queries, answerHandlers, log) type input struct { name string diff --git a/be1-go/internal/handler/channel/chirp/hchirp/chirp.go b/be1-go/internal/handler/channel/chirp/hchirp/chirp.go index ce1e9f8c30..80cb51f044 100644 --- a/be1-go/internal/handler/channel/chirp/hchirp/chirp.go +++ b/be1-go/internal/handler/channel/chirp/hchirp/chirp.go @@ -3,6 +3,7 @@ package hchirp import ( "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/errors" "popstellar/internal/handler/channel" @@ -34,15 +35,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(conf Config, subs Subscribers, - db Repository, schema *validation.SchemaValidator) *Handler { +func New(conf Config, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: conf, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "chirp").Logger(), } } diff --git a/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go b/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go index 69f6356364..21b85da120 100644 --- a/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go +++ b/be1-go/internal/handler/channel/chirp/hchirp/chirp_test.go @@ -2,8 +2,10 @@ package hchirp import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/chirp/hchirp/mocks" @@ -27,7 +29,9 @@ func Test_handleChannelChirp(t *testing.T) { contains string } - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) @@ -44,9 +48,9 @@ func Test_handleChannelChirp(t *testing.T) { serverSecretKey := crypto.Suite.Scalar().Pick(crypto.Suite.RandomStream()) serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) - conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress") + conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress", log) - chirp := New(conf, subs, db, schema) + chirp := New(conf, subs, db, schema, log) sender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sY=" wrongSender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sK=" diff --git a/be1-go/internal/handler/channel/coin/hcoin/coin.go b/be1-go/internal/handler/channel/coin/hcoin/coin.go index 19d89db55c..1ca06365ae 100644 --- a/be1-go/internal/handler/channel/coin/hcoin/coin.go +++ b/be1-go/internal/handler/channel/coin/hcoin/coin.go @@ -2,6 +2,7 @@ package hcoin import ( "encoding/base64" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/coin/mcoin" @@ -22,14 +23,15 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(subs Subscribers, db Repository, - schema *validation.SchemaValidator) *Handler { +func New(subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ subs: subs, db: db, schema: schema, + log: log.With().Str("module", "coin").Logger(), } } diff --git a/be1-go/internal/handler/channel/coin/hcoin/coin_test.go b/be1-go/internal/handler/channel/coin/hcoin/coin_test.go index d18738a9bd..ae0083282a 100644 --- a/be1-go/internal/handler/channel/coin/hcoin/coin_test.go +++ b/be1-go/internal/handler/channel/coin/hcoin/coin_test.go @@ -4,7 +4,9 @@ import ( "embed" "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/coin/hcoin/mocks" "popstellar/internal/handler/message/mmessage" @@ -27,14 +29,16 @@ type inputTestHandleChannelCoin struct { } func Test_handleChannelCoin(t *testing.T) { - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - coin := New(subs, db, schema) + coin := New(subs, db, schema, log) inputs := make([]inputTestHandleChannelCoin, 0) diff --git a/be1-go/internal/handler/channel/election/helection/election.go b/be1-go/internal/handler/channel/election/helection/election.go index d876989e32..b957244506 100644 --- a/be1-go/internal/handler/channel/election/helection/election.go +++ b/be1-go/internal/handler/channel/election/helection/election.go @@ -6,6 +6,7 @@ import ( "encoding/binary" "encoding/json" "fmt" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/errors" @@ -75,15 +76,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(conf Config, subs Subscribers, - db Repository, schema *validation.SchemaValidator) *Handler { +func New(conf Config, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: conf, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "election").Logger(), } } diff --git a/be1-go/internal/handler/channel/election/helection/election_test.go b/be1-go/internal/handler/channel/election/helection/election_test.go index 8be3134c4f..3737b812e8 100644 --- a/be1-go/internal/handler/channel/election/helection/election_test.go +++ b/be1-go/internal/handler/channel/election/helection/election_test.go @@ -3,9 +3,11 @@ package helection import ( "encoding/base64" "fmt" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "go.dedis.ch/kyber/v3" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/election/helection/mocks" @@ -34,7 +36,9 @@ func Test_handleChannelElection(t *testing.T) { var args []input - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) @@ -51,9 +55,9 @@ func Test_handleChannelElection(t *testing.T) { serverSecretKey := crypto.Suite.Scalar().Pick(crypto.Suite.RandomStream()) serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) - conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress") + conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress", log) - election := New(conf, subs, db, schema) + election := New(conf, subs, db, schema, log) laoID := base64.URLEncoding.EncodeToString([]byte("laoID")) electionID := base64.URLEncoding.EncodeToString([]byte("electionID")) diff --git a/be1-go/internal/handler/channel/federation/hfederation/federation.go b/be1-go/internal/handler/channel/federation/hfederation/federation.go index 4e9f0ad6f7..11d52b0792 100644 --- a/be1-go/internal/handler/channel/federation/hfederation/federation.go +++ b/be1-go/internal/handler/channel/federation/hfederation/federation.go @@ -7,6 +7,7 @@ import ( "encoding/json" "fmt" "github.com/gorilla/websocket" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "go.dedis.ch/kyber/v3/sign/schnorr" "popstellar/internal/crypto" @@ -18,7 +19,6 @@ import ( "popstellar/internal/handler/method/publish/mpublish" "popstellar/internal/handler/method/subscribe/msubscribe" "popstellar/internal/handler/query/mquery" - "popstellar/internal/logger" "popstellar/internal/network/socket" "popstellar/internal/validation" "strings" @@ -74,14 +74,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(hub Hub, subs Subscribers, db Repository, schema *validation.SchemaValidator) *Handler { +func New(hub Hub, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ hub: hub, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "federation").Logger(), } } @@ -457,7 +459,7 @@ func (h *Handler) connectTo(serverAddress string) (socket.Socket, error) { wg := h.hub.GetWaitGroup() stopChan := h.hub.GetStopChan() - client := socket.NewClientSocket(messageChan, closedSockets, ws, wg, stopChan, logger.Logger) + client := socket.NewClientSocket(messageChan, closedSockets, ws, wg, stopChan, h.log) wg.Add(2) diff --git a/be1-go/internal/handler/channel/federation/hfederation/federation_test.go b/be1-go/internal/handler/channel/federation/hfederation/federation_test.go index b2611fcc29..60d75c0a0a 100644 --- a/be1-go/internal/handler/channel/federation/hfederation/federation_test.go +++ b/be1-go/internal/handler/channel/federation/hfederation/federation_test.go @@ -6,8 +6,10 @@ import ( "encoding/json" "fmt" "github.com/gorilla/websocket" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "io" "net" "net/http" "popstellar/internal/handler/channel" @@ -37,13 +39,15 @@ func Test_handleChannelFederation(t *testing.T) { var args []input + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator.GenerateKeyPair(t) organizer2Pk, _, organizer2Sk, _ := generator.GenerateKeyPair(t) @@ -321,13 +325,15 @@ func Test_handleChannelFederation(t *testing.T) { } func Test_handleRequestChallenge(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator.GenerateKeyPair(t) serverPk, _, serverSk, _ := generator.GenerateKeyPair(t) @@ -372,13 +378,15 @@ func Test_handleRequestChallenge(t *testing.T) { } func Test_handleFederationExpect(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator.GenerateKeyPair(t) organizer2Pk, _, _, _ := generator.GenerateKeyPair(t) @@ -428,13 +436,15 @@ func Test_handleFederationExpect(t *testing.T) { } func Test_handleFederationInit(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator.GenerateKeyPair(t) organizer2Pk, _, _, _ := generator.GenerateKeyPair(t) @@ -506,13 +516,15 @@ func Test_handleFederationInit(t *testing.T) { } func Test_handleFederationChallenge(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator.GenerateKeyPair(t) organizer2Pk, _, organizer2Sk, _ := generator.GenerateKeyPair(t) @@ -609,13 +621,15 @@ func Test_handleFederationChallenge(t *testing.T) { } func Test_handleFederationResult(t *testing.T) { + log := zerolog.New(io.Discard) + db := mocks.NewRepository(t) - subs := state.NewSubscribers() - hub := state.NewHubParams() + subs := state.NewSubscribers(log) + hub := state.NewHubParams(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - federationHandler := New(hub, subs, db, schema) + federationHandler := New(hub, subs, db, schema, log) organizerPk, _, organizerSk, _ := generator.GenerateKeyPair(t) organizer2Pk, _, organizer2Sk, _ := generator.GenerateKeyPair(t) diff --git a/be1-go/internal/handler/channel/lao/hlao/lao.go b/be1-go/internal/handler/channel/lao/hlao/lao.go index e377acf565..aa88ee8166 100644 --- a/be1-go/internal/handler/channel/lao/hlao/lao.go +++ b/be1-go/internal/handler/channel/lao/hlao/lao.go @@ -3,6 +3,7 @@ package hlao import ( "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/errors" @@ -70,15 +71,16 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(conf Config, subs Subscribers, - db Repository, schema *validation.SchemaValidator) *Handler { +func New(conf Config, subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: conf, subs: subs, db: db, schema: schema, + log: log.With().Str("module", "lao").Logger(), } } diff --git a/be1-go/internal/handler/channel/lao/hlao/lao_test.go b/be1-go/internal/handler/channel/lao/hlao/lao_test.go index 5c9a0fec1d..469501c196 100644 --- a/be1-go/internal/handler/channel/lao/hlao/lao_test.go +++ b/be1-go/internal/handler/channel/lao/hlao/lao_test.go @@ -2,9 +2,11 @@ package hlao import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "go.dedis.ch/kyber/v3" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/lao/hlao/mocks" @@ -35,7 +37,9 @@ func Test_handleChannelLao(t *testing.T) { contains string } - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) @@ -52,9 +56,9 @@ func Test_handleChannelLao(t *testing.T) { serverSecretKey := crypto.Suite.Scalar().Pick(crypto.Suite.RandomStream()) serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) - conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress") + conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, "clientAddress", "serverAddress", log) - handler := New(conf, subs, db, schema) + handler := New(conf, subs, db, schema, log) var args []input diff --git a/be1-go/internal/handler/channel/reaction/hreaction/reaction.go b/be1-go/internal/handler/channel/reaction/hreaction/reaction.go index d83d099242..37ca30e5a5 100644 --- a/be1-go/internal/handler/channel/reaction/hreaction/reaction.go +++ b/be1-go/internal/handler/channel/reaction/hreaction/reaction.go @@ -2,6 +2,7 @@ package hreaction import ( "encoding/base64" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/reaction/mreaction" @@ -29,14 +30,15 @@ type Handler struct { subs Subscribers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(subs Subscribers, db Repository, - schema *validation.SchemaValidator) *Handler { +func New(subs Subscribers, db Repository, schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ subs: subs, db: db, schema: schema, + log: log.With().Str("module", "reaction").Logger(), } } diff --git a/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go b/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go index 8728b1d63d..000b15198c 100644 --- a/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go +++ b/be1-go/internal/handler/channel/reaction/hreaction/reaction_test.go @@ -1,7 +1,9 @@ package hreaction import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/reaction/hreaction/mocks" "popstellar/internal/handler/message/mmessage" @@ -22,14 +24,16 @@ func Test_handleChannelReaction(t *testing.T) { contains string } - subs := state.NewSubscribers() + log := zerolog.New(io.Discard) + + subs := state.NewSubscribers(log) db := mocks.NewRepository(t) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - reactionHandler := New(subs, db, schema) + reactionHandler := New(subs, db, schema, log) sender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sY=" //wrongSender := "3yPmdBu8DM7jT30IKqkPjuFFIHnubO0z4E0dV7dR4sK=" diff --git a/be1-go/internal/handler/channel/root/hroot/root.go b/be1-go/internal/handler/channel/root/hroot/root.go index 72d482513a..ae35640fb3 100644 --- a/be1-go/internal/handler/channel/root/hroot/root.go +++ b/be1-go/internal/handler/channel/root/hroot/root.go @@ -3,6 +3,7 @@ package hroot import ( "encoding/base64" "encoding/json" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/errors" @@ -51,16 +52,18 @@ type Handler struct { peers Peers db Repository schema *validation.SchemaValidator + log zerolog.Logger } -func New(config Config, db Repository, - subs Subscribers, peers Peers, schema *validation.SchemaValidator) *Handler { +func New(config Config, db Repository, subs Subscribers, peers Peers, + schema *validation.SchemaValidator, log zerolog.Logger) *Handler { return &Handler{ conf: config, subs: subs, peers: peers, db: db, schema: schema, + log: log.With().Str("module", "root").Logger(), } } diff --git a/be1-go/internal/handler/channel/root/hroot/root_test.go b/be1-go/internal/handler/channel/root/hroot/root_test.go index bafef508e1..3f68503d0c 100644 --- a/be1-go/internal/handler/channel/root/hroot/root_test.go +++ b/be1-go/internal/handler/channel/root/hroot/root_test.go @@ -3,8 +3,10 @@ package hroot import ( "encoding/base64" "fmt" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "io" "popstellar/internal/crypto" "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/root/hroot/mocks" @@ -31,6 +33,8 @@ func Test_handleChannelRoot(t *testing.T) { contains string } + log := zerolog.New(io.Discard) + organizerBuf, err := base64.URLEncoding.DecodeString(ownerPubBuf64) require.NoError(t, err) @@ -42,16 +46,16 @@ func Test_handleChannelRoot(t *testing.T) { serverPublicKey := crypto.Suite.Point().Mul(serverSecretKey, nil) conf := state.CreateConfig(ownerPublicKey, serverPublicKey, serverSecretKey, - "clientAddress", "serverAddress") + "clientAddress", "serverAddress", log) db := mocks.NewRepository(t) - subs := state.NewSubscribers() - peers := state.NewPeers() + subs := state.NewSubscribers(log) + peers := state.NewPeers(log) schema, err := validation.NewSchemaValidator() require.NoError(t, err) - rootHandler := New(conf, db, subs, peers, schema) + rootHandler := New(conf, db, subs, peers, schema, log) var args []input diff --git a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go index 4623ca63b2..f7a0997353 100644 --- a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go +++ b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc.go @@ -1,6 +1,7 @@ package hjsonrpc import ( + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/network/socket" @@ -19,13 +20,16 @@ type Handler struct { schema *validation.SchemaValidator queryHandler QueryHandler answerHandler AnswerHandler + log zerolog.Logger } -func New(schema *validation.SchemaValidator, queryHandler QueryHandler, answerHandler AnswerHandler) *Handler { +func New(schema *validation.SchemaValidator, queryHandler QueryHandler, + answerHandler AnswerHandler, log zerolog.Logger) *Handler { return &Handler{ schema: schema, queryHandler: queryHandler, answerHandler: answerHandler, + log: log.With().Str("module", "jsonrpc").Logger(), } } diff --git a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go index 00ae58ea9a..ec95e61636 100644 --- a/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go +++ b/be1-go/internal/handler/jsonrpc/hjsonrpc/jsonrpc_test.go @@ -2,7 +2,9 @@ package hjsonrpc import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/network/socket" "popstellar/internal/network/socket/mocks" "popstellar/internal/test/generator" @@ -35,7 +37,7 @@ func Test_handleIncomingMessage(t *testing.T) { queryHandler := &nullQueryHandler{} answerHandler := &nullAnswerHandler{} - handler := New(schema, queryHandler, answerHandler) + handler := New(schema, queryHandler, answerHandler, zerolog.New(io.Discard)) args := make([]input, 0) diff --git a/be1-go/internal/handler/message/hmessage/message.go b/be1-go/internal/handler/message/hmessage/message.go index eda77da3ba..f5a971c1bb 100644 --- a/be1-go/internal/handler/message/hmessage/message.go +++ b/be1-go/internal/handler/message/hmessage/message.go @@ -1,6 +1,7 @@ package hmessage import ( + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/message/mmessage" @@ -32,12 +33,14 @@ type DataHandlers struct { type Handler struct { db Repository handlers DataHandlers + log zerolog.Logger } -func New(db Repository, handlers DataHandlers) *Handler { +func New(db Repository, handlers DataHandlers, log zerolog.Logger) *Handler { return &Handler{ db: db, handlers: handlers, + log: log.With().Str("module", "message").Logger(), } } diff --git a/be1-go/internal/handler/message/hmessage/message_test.go b/be1-go/internal/handler/message/hmessage/message_test.go index 6cc438a0aa..c9c10cf646 100644 --- a/be1-go/internal/handler/message/hmessage/message_test.go +++ b/be1-go/internal/handler/message/hmessage/message_test.go @@ -2,8 +2,10 @@ package hmessage import ( "encoding/base64" + "github.com/rs/zerolog" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/channel" "popstellar/internal/handler/message/hmessage/mocks" "popstellar/internal/handler/message/mmessage" @@ -26,7 +28,7 @@ func Test_handleChannel(t *testing.T) { Federation: dataHandler, } - msgHandler := New(db, subHandlers) + msgHandler := New(db, subHandlers, zerolog.New(io.Discard)) _, publicBuf, private, _ := generator.GenerateKeyPair(t) sender := base64.URLEncoding.EncodeToString(publicBuf) diff --git a/be1-go/internal/handler/method/catchup/hcatchup/catchup.go b/be1-go/internal/handler/method/catchup/hcatchup/catchup.go index 2c7b659a07..9e50a55277 100644 --- a/be1-go/internal/handler/method/catchup/hcatchup/catchup.go +++ b/be1-go/internal/handler/method/catchup/hcatchup/catchup.go @@ -2,6 +2,7 @@ package hcatchup import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/catchup/mcatchup" @@ -14,12 +15,14 @@ type Repository interface { } type Handler struct { - db Repository + db Repository + log zerolog.Logger } -func New(db Repository) *Handler { +func New(db Repository, log zerolog.Logger) *Handler { return &Handler{ - db: db, + db: db, + log: log.With().Str("module", "catchup").Logger(), } } diff --git a/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go b/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go index 1b8bf2e41d..69b65fe42c 100644 --- a/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go +++ b/be1-go/internal/handler/method/catchup/hcatchup/catchup_test.go @@ -1,8 +1,10 @@ package hcatchup import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/catchup/hcatchup/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -13,7 +15,7 @@ import ( func Test_handleCatchUp(t *testing.T) { db := mocks.NewRepository(t) - handler := New(db) + handler := New(db, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go index 4956a27862..311cf44ab4 100644 --- a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go +++ b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid.go @@ -2,6 +2,7 @@ package hgetmessagesbyid import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" @@ -13,12 +14,14 @@ type Repository interface { } type Handler struct { - db Repository + db Repository + log zerolog.Logger } -func New(db Repository) *Handler { +func New(db Repository, log zerolog.Logger) *Handler { return &Handler{ - db: db, + db: db, + log: log.With().Str("module", "getmessagesbyid").Logger(), } } diff --git a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go index 485fa357c2..12d0ab6a1f 100644 --- a/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go +++ b/be1-go/internal/handler/method/getmessagesbyid/hgetmessagesbyid/getmessagesbyid_test.go @@ -1,8 +1,10 @@ package hgetmessagesbyid import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/getmessagesbyid/hgetmessagesbyid/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -13,7 +15,7 @@ import ( func Test_handleGetMessagesByID(t *testing.T) { db := mocks.NewRepository(t) - handler := New(db) + handler := New(db, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go index b2cf13ab6d..8f764b3787 100644 --- a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go +++ b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver.go @@ -2,6 +2,7 @@ package hgreetserver import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/handler/method/greetserver/mgreetserver" @@ -22,12 +23,14 @@ type Peers interface { type Handler struct { conf Config peers Peers + log zerolog.Logger } -func New(conf Config, peers Peers) *Handler { +func New(conf Config, peers Peers, log zerolog.Logger) *Handler { return &Handler{ conf: conf, peers: peers, + log: log.With().Str("module", "greetserver").Logger(), } } diff --git a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go index 83c6c0e031..80668280ec 100644 --- a/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go +++ b/be1-go/internal/handler/method/greetserver/hgreetserver/greetserver_test.go @@ -1,7 +1,9 @@ package hgreetserver import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/errors" mocks2 "popstellar/internal/handler/method/greetserver/hgreetserver/mocks" "popstellar/internal/network/socket/mocks" @@ -13,7 +15,7 @@ func Test_handleGreetServer(t *testing.T) { conf := mocks2.NewConfig(t) peers := mocks2.NewPeers(t) - handler := New(conf, peers) + handler := New(conf, peers, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go index 0afb4f6f54..76c0b59032 100644 --- a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go +++ b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat.go @@ -2,6 +2,7 @@ package hheartbeat import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" @@ -23,12 +24,14 @@ type Repository interface { type Handler struct { queries Queries db Repository + log zerolog.Logger } -func New(queries Queries, db Repository) *Handler { +func New(queries Queries, db Repository, log zerolog.Logger) *Handler { return &Handler{ queries: queries, db: db, + log: log.With().Str("module", "heartbeat").Logger(), } } diff --git a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go index 25e25ab6f3..2423430d6c 100644 --- a/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go +++ b/be1-go/internal/handler/method/heartbeat/hheartbeat/heartbeat_test.go @@ -2,9 +2,11 @@ package hheartbeat import ( "encoding/json" + "github.com/rs/zerolog" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "golang.org/x/xerrors" + "io" "popstellar/internal/handler/method/getmessagesbyid/mgetmessagesbyid" mocks2 "popstellar/internal/handler/method/heartbeat/hheartbeat/mocks" "popstellar/internal/network/socket/mocks" @@ -16,7 +18,7 @@ func Test_handleHeartbeat(t *testing.T) { queries := mocks2.NewQueries(t) db := mocks2.NewRepository(t) - handler := New(queries, db) + handler := New(queries, db, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/publish/hpublish/publish.go b/be1-go/internal/handler/method/publish/hpublish/publish.go index 5e27f52ca2..7d28cc7601 100644 --- a/be1-go/internal/handler/method/publish/hpublish/publish.go +++ b/be1-go/internal/handler/method/publish/hpublish/publish.go @@ -2,6 +2,7 @@ package hpublish import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/publish/mpublish" @@ -29,13 +30,15 @@ type Handler struct { hub Hub db Repository messageHandler MessageHandler + log zerolog.Logger } -func New(hub Hub, db Repository, messageHandler MessageHandler) *Handler { +func New(hub Hub, db Repository, messageHandler MessageHandler, log zerolog.Logger) *Handler { return &Handler{ hub: hub, db: db, messageHandler: messageHandler, + log: log.With().Str("module", "publish").Logger(), } } diff --git a/be1-go/internal/handler/method/rumor/hrumor/rumor.go b/be1-go/internal/handler/method/rumor/hrumor/rumor.go index 6c66f8d7dd..e93bcd2fe2 100644 --- a/be1-go/internal/handler/method/rumor/hrumor/rumor.go +++ b/be1-go/internal/handler/method/rumor/hrumor/rumor.go @@ -2,6 +2,7 @@ package hrumor import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/message/mmessage" "popstellar/internal/handler/method/rumor/mrumor" @@ -41,15 +42,16 @@ type Handler struct { sockets Sockets db Repository messageHandler MessageHandler + log zerolog.Logger } -func New(queries Queries, sockets Sockets, db Repository, - messageHandler MessageHandler) *Handler { +func New(queries Queries, sockets Sockets, db Repository, messageHandler MessageHandler, log zerolog.Logger) *Handler { return &Handler{ queries: queries, sockets: sockets, db: db, messageHandler: messageHandler, + log: log.With().Str("module", "rumor").Logger(), } } diff --git a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go index a0fba7e144..400b51b43e 100644 --- a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go +++ b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe.go @@ -2,6 +2,7 @@ package hsubscribe import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/method/subscribe/msubscribe" @@ -14,10 +15,14 @@ type Subscribers interface { type Handler struct { subs Subscribers + log zerolog.Logger } -func New(subs Subscribers) *Handler { - return &Handler{subs: subs} +func New(subs Subscribers, log zerolog.Logger) *Handler { + return &Handler{ + subs: subs, + log: log.With().Str("module", "subscribe").Logger(), + } } func (h *Handler) Handle(socket socket.Socket, msg []byte) (*int, error) { diff --git a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go index 7c0bdfac1f..9ff78e6968 100644 --- a/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go +++ b/be1-go/internal/handler/method/subscribe/hsubscribe/subscribe_test.go @@ -1,7 +1,9 @@ package hsubscribe import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/errors" "popstellar/internal/handler/method/subscribe/hsubscribe/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -12,7 +14,7 @@ import ( func Test_handleSubscribe(t *testing.T) { subs := mocks.NewSubscribers(t) - handler := New(subs) + handler := New(subs, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go index 8490bde241..8a333373e1 100644 --- a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go +++ b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe.go @@ -2,6 +2,7 @@ package hunsubscribe import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/channel" "popstellar/internal/handler/method/unsubscribe/munsubscribe" @@ -14,10 +15,14 @@ type Subscribers interface { type Handler struct { subs Subscribers + log zerolog.Logger } -func New(subs Subscribers) *Handler { - return &Handler{subs: subs} +func New(subs Subscribers, log zerolog.Logger) *Handler { + return &Handler{ + subs: subs, + log: log.With().Str("module", "unsubscribe").Logger(), + } } func (h *Handler) Handle(socket socket.Socket, msg []byte) (*int, error) { diff --git a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go index 0eb0af0302..f5e336cbf7 100644 --- a/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go +++ b/be1-go/internal/handler/method/unsubscribe/hunsubscribe/unsubscribe_test.go @@ -1,7 +1,9 @@ package hunsubscribe import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/errors" "popstellar/internal/handler/method/unsubscribe/hunsubscribe/mocks" mocks2 "popstellar/internal/network/socket/mocks" @@ -12,7 +14,7 @@ import ( func Test_handleUnsubscribe(t *testing.T) { subs := mocks.NewSubscribers(t) - handler := New(subs) + handler := New(subs, zerolog.New(io.Discard)) type input struct { name string diff --git a/be1-go/internal/handler/query/hquery/query.go b/be1-go/internal/handler/query/hquery/query.go index 00036db265..1f87692b6f 100644 --- a/be1-go/internal/handler/query/hquery/query.go +++ b/be1-go/internal/handler/query/hquery/query.go @@ -2,6 +2,7 @@ package hquery import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/query/mquery" "popstellar/internal/network/socket" @@ -24,11 +25,13 @@ type MethodHandlers struct { type Handler struct { handlers MethodHandlers + log zerolog.Logger } -func New(handlers MethodHandlers) *Handler { +func New(handlers MethodHandlers, log zerolog.Logger) *Handler { return &Handler{ handlers: handlers, + log: log.With().Str("module", "query").Logger(), } } diff --git a/be1-go/internal/handler/query/hquery/query_test.go b/be1-go/internal/handler/query/hquery/query_test.go index 5b71edf3c9..8bccd725db 100644 --- a/be1-go/internal/handler/query/hquery/query_test.go +++ b/be1-go/internal/handler/query/hquery/query_test.go @@ -1,7 +1,9 @@ package hquery import ( + "github.com/rs/zerolog" "github.com/stretchr/testify/require" + "io" "popstellar/internal/handler/query/hquery/mocks" mocks2 "popstellar/internal/network/socket/mocks" "popstellar/internal/test/generator" @@ -29,7 +31,7 @@ func Test_handleQuery(t *testing.T) { Rumor: methodHandler, } - handler := New(methodHandlers) + handler := New(methodHandlers, zerolog.New(io.Discard)) args := make([]input, 0) diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index d373333b93..56a8f13b82 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -2,10 +2,12 @@ package hub import ( "encoding/json" + "errors" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "popstellar/internal/crypto" "popstellar/internal/database/sqlite" - "popstellar/internal/errors" + poperrors "popstellar/internal/errors" "popstellar/internal/handler/answer/hanswer" "popstellar/internal/handler/channel/chirp/hchirp" "popstellar/internal/handler/channel/coin/hcoin" @@ -24,12 +26,11 @@ import ( "popstellar/internal/handler/method/heartbeat/mheartbeat" "popstellar/internal/handler/method/publish/hpublish" "popstellar/internal/handler/method/rumor/hrumor" - method2 "popstellar/internal/handler/method/rumor/mrumor" + "popstellar/internal/handler/method/rumor/mrumor" "popstellar/internal/handler/method/subscribe/hsubscribe" "popstellar/internal/handler/method/unsubscribe/hunsubscribe" "popstellar/internal/handler/query/hquery" "popstellar/internal/handler/query/mquery" - "popstellar/internal/logger" "popstellar/internal/network/socket" "popstellar/internal/state" "popstellar/internal/validation" @@ -55,7 +56,7 @@ type Sockets interface { type Repository interface { // GetAndIncrementMyRumor return false if the last rumor is empty otherwise returns the new rumor to send and create the next rumor - GetAndIncrementMyRumor() (bool, method2.Rumor, error) + GetAndIncrementMyRumor() (bool, mrumor.Rumor, error) GetParamsHeartbeat() (map[string][]string, error) } @@ -69,7 +70,7 @@ type GreetServerSender interface { } type RumorSender interface { - SendRumor(socket socket.Socket, rumor method2.Rumor) + SendRumor(socket socket.Socket, rumor mrumor.Rumor) } type Hub struct { @@ -90,19 +91,21 @@ type Hub struct { jsonRpcHandler JsonRpcHandler greetserverSender GreetServerSender rumorSender RumorSender + + log zerolog.Logger } -func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress string) (*Hub, error) { +func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress string, log zerolog.Logger) (*Hub, error) { // Initialize the in memory states - subs := state.NewSubscribers() - peers := state.NewPeers() - queries := state.NewQueries(&logger.Logger) - hubParams := state.NewHubParams() - sockets := state.NewSockets() + subs := state.NewSubscribers(log) + peers := state.NewPeers(log) + queries := state.NewQueries(log) + hubParams := state.NewHubParams(log) + sockets := state.NewSockets(log) // Initialize the database - db, err := sqlite.NewSQLite(dbPath, true) + db, err := sqlite.NewSQLite(dbPath, true, log) if err != nil { return nil, err } @@ -121,7 +124,7 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st } // Create the in memory configuration state - conf := state.CreateConfig(ownerPubKey, serverPublicKey, serverSecretKey, clientAddress, serverAddress) + conf := state.CreateConfig(ownerPubKey, serverPublicKey, serverSecretKey, clientAddress, serverAddress, log) // Store the rumor with id 0 associated to the server if the database is empty err = db.StoreFirstRumor() @@ -155,44 +158,44 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st // Create the message data handlers dataHandlers := hmessage.DataHandlers{ - Root: hroot.New(conf, &db, subs, peers, schemaValidator), - Lao: hlao.New(conf, subs, &db, schemaValidator), - Election: helection.New(conf, subs, &db, schemaValidator), - Chirp: hchirp.New(conf, subs, &db, schemaValidator), - Reaction: hreaction.New(subs, &db, schemaValidator), - Coin: hcoin.New(subs, &db, schemaValidator), - Federation: hfederation.New(hubParams, subs, &db, schemaValidator), + Root: hroot.New(conf, &db, subs, peers, schemaValidator, log), + Lao: hlao.New(conf, subs, &db, schemaValidator, log), + Election: helection.New(conf, subs, &db, schemaValidator, log), + Chirp: hchirp.New(conf, subs, &db, schemaValidator, log), + Reaction: hreaction.New(subs, &db, schemaValidator, log), + Coin: hcoin.New(subs, &db, schemaValidator, log), + Federation: hfederation.New(hubParams, subs, &db, schemaValidator, log), } // Create the message handler - msgHandler := hmessage.New(&db, dataHandlers) + msgHandler := hmessage.New(&db, dataHandlers, log) // Create the greetserver handler - greetserverHandler := hgreetserver.New(conf, peers) + greetserverHandler := hgreetserver.New(conf, peers, log) // Create the rumor handler - rumorHandler := hrumor.New(queries, sockets, &db, msgHandler) + rumorHandler := hrumor.New(queries, sockets, &db, msgHandler, log) // Create the query handler qHandler := hquery.New(hquery.MethodHandlers{ - Catchup: hcatchup.New(&db), - GetMessagesbyid: hgetmessagesbyid.New(&db), + Catchup: hcatchup.New(&db, log), + GetMessagesbyid: hgetmessagesbyid.New(&db, log), Greetserver: greetserverHandler, - Heartbeat: hheartbeat.New(queries, &db), - Publish: hpublish.New(hubParams, &db, msgHandler), - Subscribe: hsubscribe.New(subs), - Unsubscribe: hunsubscribe.New(subs), + Heartbeat: hheartbeat.New(queries, &db, log), + Publish: hpublish.New(hubParams, &db, msgHandler, log), + Subscribe: hsubscribe.New(subs, log), + Unsubscribe: hunsubscribe.New(subs, log), Rumor: rumorHandler, - }) + }, log) // Create the answer handler aHandler := hanswer.New(queries, hanswer.Handlers{ MessageHandler: msgHandler, RumorSender: rumorHandler, - }) + }, log) // Create the json rpc handler - jsonRpcHandler := hjsonrpc.New(schemaValidator, qHandler, aHandler) + jsonRpcHandler := hjsonrpc.New(schemaValidator, qHandler, aHandler, log) // Create the hub hub := &Hub{ @@ -207,6 +210,7 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st jsonRpcHandler: jsonRpcHandler, greetserverSender: greetserverHandler, rumorSender: rumorHandler, + log: log.With().Str("module", "hub").Logger(), } return hub, nil @@ -242,23 +246,35 @@ func (h *Hub) SendGreetServer(socket socket.Socket) error { func (h *Hub) runMessageReceiver() { defer h.wg.Done() - defer logger.Logger.Info().Msg("stopping hub") + defer h.log.Info().Msg("stopping hub") - logger.Logger.Info().Msg("starting hub") + h.log.Info().Msg("starting hub") for { - logger.Logger.Debug().Msg("waiting for a new message") + h.log.Debug().Msg("waiting for a new message") select { case incomingMessage := <-h.messageChan: - logger.Logger.Debug().Msg("start handling a message") + h.log.Debug().Msg("start handling a message") err := h.jsonRpcHandler.Handle(incomingMessage.Socket, incomingMessage.Message) if err != nil { - logger.Logger.Error().Err(err) + popError := &poperrors.PopError{} + if !errors.As(err, &popError) { + popError = poperrors.NewPopError(poperrors.InternalServerErrorCode, err.Error()) + } + + stack, err := popError.GetStackTraceJSON() + if err != nil { + h.log.Error().Err(err).Msg("failed to get stacktrace") + h.log.Error().Err(popError).Msg("") + } else { + h.log.Error().Err(popError).RawJSON("stacktrace", stack).Msg("") + } + } else { - logger.Logger.Debug().Msg("successfully handled a message") + h.log.Debug().Msg("successfully handled a message") } case socketID := <-h.closedSockets: - logger.Logger.Debug().Msgf("stopping the Socket " + socketID) + h.log.Debug().Msgf("stopping the Socket " + socketID) h.subs.UnsubscribeFromAll(socketID) case <-h.stop: return @@ -270,24 +286,24 @@ func (h *Hub) runRumorSender() { ticker := time.NewTicker(rumorDelay) defer ticker.Stop() defer h.wg.Done() - defer logger.Logger.Info().Msg("stopping rumor sender") + defer h.log.Info().Msg("stopping rumor sender") - logger.Logger.Info().Msg("starting rumor sender") + h.log.Info().Msg("starting rumor sender") for { select { case <-ticker.C: - logger.Logger.Debug().Msgf("sender rumor trigerred") + h.log.Debug().Msgf("sender rumor trigerred") err := h.tryToSendRumor() if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } case <-h.resetRumorSender: - logger.Logger.Debug().Msgf("sender rumor reset") + h.log.Debug().Msgf("sender rumor reset") ticker.Reset(rumorDelay) err := h.tryToSendRumor() if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } case <-h.stop: return @@ -301,7 +317,7 @@ func (h *Hub) tryToSendRumor() error { return err } if !ok { - logger.Logger.Debug().Msg("no new rumor to send") + h.log.Debug().Msg("no new rumor to send") return nil } @@ -314,16 +330,16 @@ func (h *Hub) runHeartbeat() { ticker := time.NewTicker(heartbeatDelay) defer ticker.Stop() defer h.wg.Done() - defer logger.Logger.Info().Msg("stopping heartbeat sender") + defer h.log.Info().Msg("stopping heartbeat sender") - logger.Logger.Info().Msg("starting heartbeat sender") + h.log.Info().Msg("starting heartbeat sender") for { select { case <-ticker.C: err := h.sendHeartbeat() if err != nil { - logger.Logger.Error().Err(err) + h.log.Error().Err(err) } case <-h.stop: return @@ -345,7 +361,7 @@ func (h *Hub) sendHeartbeat() error { buf, err := json.Marshal(heartbeatMessage) if err != nil { - return errors.NewJsonMarshalError(err.Error()) + return poperrors.NewJsonMarshalError(err.Error()) } h.sockets.SendToAll(buf) diff --git a/be1-go/internal/logger/logger.go b/be1-go/internal/logger/logger.go index 7cafea731a..7e15e4b2bd 100644 --- a/be1-go/internal/logger/logger.go +++ b/be1-go/internal/logger/logger.go @@ -35,7 +35,7 @@ var ShortSHA = "unknown" // level. const EnvLogLevel = "LLVL" -const defaultLevel = zerolog.DebugLevel +const defaultLevel = zerolog.InfoLevel func init() { lvl := os.Getenv(EnvLogLevel) diff --git a/be1-go/internal/network/server.go b/be1-go/internal/network/server.go index 4cd77d2fdd..b9a2f763a0 100644 --- a/be1-go/internal/network/server.go +++ b/be1-go/internal/network/server.go @@ -48,7 +48,11 @@ type Server struct { // // endpoint. Please use the Start() method to start // listening for connections. func NewServer(hub hub.Hub, addr string, port int, st socket.SocketType, log zerolog.Logger) *Server { - log = log.With().Str("role", "server").Logger() + if st == socket.ClientSocketType { + log = log.With().Str("server", "client").Logger() + } else { + log = log.With().Str("server", "server").Logger() + } server := &Server{ hub: hub, diff --git a/be1-go/internal/network/socket/socket_impl.go b/be1-go/internal/network/socket/socket_impl.go index 455a80c2a0..def8acd363 100644 --- a/be1-go/internal/network/socket/socket_impl.go +++ b/be1-go/internal/network/socket/socket_impl.go @@ -81,15 +81,14 @@ func (s *baseSocket) ReadPump() { _, message, err := s.conn.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { - s.log.Err(err). - Str("socket", s.conn.RemoteAddr().String()). - Msg("connection dropped unexpectedly") + s.log.Err(err).Msg("connection dropped unexpectedly") } else { s.log.Info().Msg("closing the read pump") } break } + s.log.Info().RawJSON("received", message).Msg("") msg := IncomingMessage{ Socket: s, Message: message, @@ -134,6 +133,7 @@ func (s *baseSocket) WritePump() { } w.Write(message) + s.log.Info().RawJSON("sent", message).Msg("") if err := w.Close(); err != nil { s.log.Err(err).Msg("failed to close writer") @@ -155,10 +155,6 @@ func (s *baseSocket) WritePump() { // Send allows sending a serialized message to the socket. func (s *baseSocket) Send(msg []byte) { - s.log.Info(). - Str("to", s.conn.RemoteAddr().String()). - Str("msg", string(msg)). - Msg("send generic msg") s.send <- msg } @@ -185,11 +181,6 @@ func (s *baseSocket) SendError(id *int, err error) { return } - s.log.Info(). - Str("to", s.conn.RemoteAddr().String()). - Str("msg", string(answerBuf)). - Msg("send error") - s.send <- answerBuf } @@ -199,7 +190,7 @@ func (s *baseSocket) SendPopError(id *int, err error) { popError := &poperror.PopError{} if !errors.As(err, &popError) { - popError = poperror.NewPopError(-6, err.Error()) + popError = poperror.NewPopError(poperror.InternalServerErrorCode, err.Error()) } description := popError.Error() + "\n" + popError.StackTraceString() @@ -223,11 +214,6 @@ func (s *baseSocket) SendPopError(id *int, err error) { return } - s.log.Info(). - Str("to", s.conn.RemoteAddr().String()). - Str("msg", string(answerBuf)). - Msg("send error") - s.send <- answerBuf } @@ -278,10 +264,6 @@ func (s *baseSocket) SendResult(id int, res []mmessage.Message, missingMessagesB return } - s.log.Info(). - Str("to", s.id). - Str("msg", string(answerBuf)). - Msg("send result") s.send <- answerBuf } @@ -289,8 +271,18 @@ func newBaseSocket(socketType SocketType, receiver chan<- IncomingMessage, closedSockets chan<- string, conn *websocket.Conn, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger, ) *baseSocket { + id := xid.New().String() + + if conn != nil { + log = log.With().Dict("socket", zerolog.Dict(). + Str("ID", id). + Str("IP", conn.RemoteAddr().String())).Logger() + } else { + log = log.With().Str("socketID", id).Logger() + } + return &baseSocket{ - id: xid.New().String(), + id: id, socketType: socketType, receiver: receiver, closedSockets: closedSockets, @@ -312,8 +304,6 @@ func NewClientSocket(receiver chan<- IncomingMessage, closedSockets chan<- string, conn *websocket.Conn, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger, ) *ClientSocket { - log = log.With().Str("role", "client socket").Logger() - return &ClientSocket{ baseSocket: newBaseSocket(ClientSocketType, receiver, closedSockets, conn, wg, done, log), @@ -330,8 +320,6 @@ func NewServerSocket(receiver chan<- IncomingMessage, closedSockets chan<- string, conn *websocket.Conn, wg *sync.WaitGroup, done chan struct{}, log zerolog.Logger, ) *ServerSocket { - log = log.With().Str("role", "server socket").Logger() - return &ServerSocket{ baseSocket: newBaseSocket(ServerSocketType, receiver, closedSockets, conn, wg, done, log), diff --git a/be1-go/internal/network/socket/socket_impl_test.go b/be1-go/internal/network/socket/socket_impl_test.go index 4d1a1213a5..68d3dc4c14 100644 --- a/be1-go/internal/network/socket/socket_impl_test.go +++ b/be1-go/internal/network/socket/socket_impl_test.go @@ -2,7 +2,6 @@ package socket import ( "encoding/json" - "github.com/gorilla/websocket" "github.com/rs/zerolog" "github.com/stretchr/testify/require" "os" @@ -88,7 +87,7 @@ var socket = *newBaseSocket( ServerSocketType, make(chan IncomingMessage), make(chan string), - &websocket.Conn{}, + nil, &sync.WaitGroup{}, make(chan struct{}), zerolog.New(zerolog.ConsoleWriter{Out: os.Stdout}).With().Timestamp().Logger(), diff --git a/be1-go/internal/old/hub/standard_hub/message_handling.go b/be1-go/internal/old/hub/standard_hub/message_handling.go index a6d4df54e2..ee7a2496f2 100644 --- a/be1-go/internal/old/hub/standard_hub/message_handling.go +++ b/be1-go/internal/old/hub/standard_hub/message_handling.go @@ -22,8 +22,6 @@ import ( "popstellar/internal/old/hub/standard_hub/hub_state" "popstellar/internal/validation" - "github.com/rs/zerolog/log" - "go.dedis.ch/kyber/v3/sign/schnorr" "golang.org/x/exp/slices" @@ -523,7 +521,7 @@ func (h *Hub) handleReceivedMessage(socket socket.Socket, messageData mmessage.M signature := messageData.Signature messageID := messageData.MessageID data := messageData.Data - log.Info().Msgf("Received message on %s", targetChannel) + //log.Info().Msgf("Received message on %s", targetChannel) expectedMessageID := channel.Hash(data, signature) if expectedMessageID != messageID { diff --git a/be1-go/internal/old/oldchannel/authentication/authentication_test.go b/be1-go/internal/old/oldchannel/authentication/authentication_test.go index 51f9253972..94181f0060 100644 --- a/be1-go/internal/old/oldchannel/authentication/authentication_test.go +++ b/be1-go/internal/old/oldchannel/authentication/authentication_test.go @@ -7,7 +7,6 @@ import ( "github.com/gorilla/websocket" "github.com/rs/xid" "github.com/rs/zerolog" - "github.com/rs/zerolog/log" "github.com/stretchr/testify/require" "go.dedis.ch/kyber/v3" "go.dedis.ch/kyber/v3/sign/schnorr" @@ -25,7 +24,6 @@ import ( "popstellar/internal/handler/method/broadcast/mbroadcast" "popstellar/internal/handler/method/greetserver/mgreetserver" method2 "popstellar/internal/handler/method/publish/mpublish" - "popstellar/internal/logger" "popstellar/internal/network/socket" "popstellar/internal/old/oldchannel" "popstellar/internal/validation" @@ -54,7 +52,7 @@ func TestJWTToken(t *testing.T) { idToken, err := createJWTString(webAddr, ppid, cID, nonce, sk) require.NoError(t, err) - log.Info().Msg(idToken) + //log.Info().Msg(idToken) // verifying the token token, err := jwt.Parse(idToken, func(jwtToken *jwt.Token) (interface{}, error) { _, ok := jwtToken.Method.(*jwt.SigningMethodRSA) @@ -106,7 +104,7 @@ func Test_Authenticate_User(t *testing.T) { require.NoError(t, err) name := "3hfd5xSty1VShCdcfLUDsgNF_EnMSRiFk74xvH5LRjM=/authenticate" // Create the oldchannel - authCha := NewChannel("3hfd5xSty1VShCdcfLUDsgNF_EnMSRiFk74xvH5LRjM=/authenticate", fakeHub, logger.Logger, secPathTest, pubPathtest) + authCha := NewChannel("3hfd5xSty1VShCdcfLUDsgNF_EnMSRiFk74xvH5LRjM=/authenticate", fakeHub, zerolog.New(io.Discard), secPathTest, pubPathtest) fakeHub.RegisterNewChannel(name, authCha) _, found := fakeHub.channelByID[name] diff --git a/be1-go/internal/old/oldchannel/lao/lao.go b/be1-go/internal/old/oldchannel/lao/lao.go index d978472388..1d8dc8aad3 100644 --- a/be1-go/internal/old/oldchannel/lao/lao.go +++ b/be1-go/internal/old/oldchannel/lao/lao.go @@ -35,8 +35,6 @@ import ( "go.dedis.ch/kyber/v3" - "github.com/rs/zerolog/log" - "github.com/rs/zerolog" "go.dedis.ch/kyber/v3/sign/schnorr" "golang.org/x/xerrors" @@ -610,7 +608,7 @@ func createGeneralChirpingChannel(laoID string, hub oldchannel.HubFunctionalitie generalChirpingChannel := generalChirping.NewChannel(generalChannelPath, hub, popstellar.Logger) hub.NotifyNewChannel(generalChannelPath, generalChirpingChannel, socket) - log.Info().Msgf("storing new oldchannel '%s' ", generalChannelPath) + //log.Info().Msgf("storing new oldchannel '%s' ", generalChannelPath) return generalChirpingChannel } @@ -620,7 +618,7 @@ func (c *Channel) createChirpingChannel(publicKey string, socket socket.Socket) cha := chirp.NewChannel(chirpingChannelPath, publicKey, c.hub, c.general, popstellar.Logger) c.hub.NotifyNewChannel(chirpingChannelPath, cha, socket) - log.Info().Msgf("storing new chirp oldchannel (%s) for: '%s'", c.channelID, publicKey) + //log.Info().Msgf("storing new chirp oldchannel (%s) for: '%s'", c.channelID, publicKey) } // createAuthChannel creates an authentication oldchannel associated to the laoID, handling PopCHA requests diff --git a/be1-go/internal/state/config.go b/be1-go/internal/state/config.go index 0530a60ac7..213d8039f5 100644 --- a/be1-go/internal/state/config.go +++ b/be1-go/internal/state/config.go @@ -2,6 +2,7 @@ package state import ( "encoding/base64" + "github.com/rs/zerolog" "go.dedis.ch/kyber/v3" "go.dedis.ch/kyber/v3/sign/schnorr" "popstellar/internal/crypto" @@ -14,16 +15,18 @@ type Config struct { serverSecretKey kyber.Scalar clientServerAddress string serverServerAddress string + log zerolog.Logger } func CreateConfig(ownerPubKey, serverPubKey kyber.Point, serverSecretKey kyber.Scalar, - clientServerAddress, serverServerAddress string) *Config { + clientServerAddress, serverServerAddress string, log zerolog.Logger) *Config { return &Config{ ownerPubKey: ownerPubKey, serverPubKey: serverPubKey, serverSecretKey: serverSecretKey, clientServerAddress: clientServerAddress, serverServerAddress: serverServerAddress, + log: log.With().Str("module", "config").Logger(), } } diff --git a/be1-go/internal/state/hub_params.go b/be1-go/internal/state/hub_params.go index 8d5e309446..bce4f027ce 100644 --- a/be1-go/internal/state/hub_params.go +++ b/be1-go/internal/state/hub_params.go @@ -1,6 +1,7 @@ package state import ( + "github.com/rs/zerolog" "popstellar/internal/network/socket" "sync" ) @@ -11,14 +12,16 @@ type HubParams struct { closedSockets chan string stop chan struct{} resetRumorSender chan struct{} + log zerolog.Logger } -func NewHubParams() *HubParams { +func NewHubParams(log zerolog.Logger) *HubParams { return &HubParams{ messageChan: make(chan socket.IncomingMessage), stop: make(chan struct{}), closedSockets: make(chan string), resetRumorSender: make(chan struct{}), + log: log.With().Str("module", "hub_params").Logger(), } } diff --git a/be1-go/internal/state/peers.go b/be1-go/internal/state/peers.go index 29bee488e1..31cb1faa88 100644 --- a/be1-go/internal/state/peers.go +++ b/be1-go/internal/state/peers.go @@ -1,6 +1,7 @@ package state import ( + "github.com/rs/zerolog" "golang.org/x/exp/maps" "golang.org/x/exp/slices" "popstellar/internal/errors" @@ -15,13 +16,15 @@ type Peers struct { peersInfo map[string]mgreetserver.GreetServerParams // peersGreeted stores the peers that were greeted by the socket ID peersGreeted map[string]struct{} + log zerolog.Logger } // NewPeers creates a new Peers structure -func NewPeers() *Peers { +func NewPeers(log zerolog.Logger) *Peers { return &Peers{ peersInfo: make(map[string]mgreetserver.GreetServerParams), peersGreeted: make(map[string]struct{}), + log: log.With().Str("module", "peers").Logger(), } } diff --git a/be1-go/internal/state/queries.go b/be1-go/internal/state/queries.go index f16c44a347..6cf6d16934 100644 --- a/be1-go/internal/state/queries.go +++ b/be1-go/internal/state/queries.go @@ -20,17 +20,18 @@ type Queries struct { // nextID store the ID of the next query nextID int + // zerolog - log *zerolog.Logger + log zerolog.Logger } // NewQueries creates a new queries struct -func NewQueries(log *zerolog.Logger) *Queries { +func NewQueries(log zerolog.Logger) *Queries { return &Queries{ state: make(map[int]bool), getMessagesByIdQueries: make(map[int]mgetmessagesbyid.GetMessagesById), getRumorQueries: make(map[int]mrumor.Rumor), - log: log, + log: log.With().Str("module", "queries").Logger(), } } @@ -68,8 +69,7 @@ func (q *Queries) SetQueryReceived(id int) error { } if currentState { - q.log.Info().Msgf("query with id %d already answered", id) - return nil + return errors.NewDuplicateResourceError("query with id %d already answered", id) } q.state[id] = true diff --git a/be1-go/internal/state/sockets.go b/be1-go/internal/state/sockets.go index d5b41e9214..5dc5f2bd32 100644 --- a/be1-go/internal/state/sockets.go +++ b/be1-go/internal/state/sockets.go @@ -2,18 +2,19 @@ package state import ( "fmt" + "github.com/rs/zerolog" "math/rand" - "popstellar/internal/logger" "popstellar/internal/network/socket" "sync" ) // NewSockets returns a new initialized Sockets -func NewSockets() *Sockets { +func NewSockets(log zerolog.Logger) *Sockets { return &Sockets{ rState: make(map[string]rumorState), socketIDs: make([]string, 0), store: make(map[string]socket.Socket), + log: log.With().Str("module", "sockets").Logger(), } } @@ -29,6 +30,7 @@ type Sockets struct { rState map[string]rumorState socketIDs []string store map[string]socket.Socket + log zerolog.Logger } func (s *Sockets) newRumorState(socket socket.Socket) rumorState { @@ -83,7 +85,7 @@ func (s *Sockets) SendRumor(socket socket.Socket, senderID string, rumorID int, } if rState.counter >= len(s.store) { - logger.Logger.Debug().Msgf("stop sending rumor because completed cycle") + s.log.Debug().Msgf("stop sending rumor because completed cycle") return } diff --git a/be1-go/internal/state/subscribers.go b/be1-go/internal/state/subscribers.go index 75f478dbc3..a016edcb26 100644 --- a/be1-go/internal/state/subscribers.go +++ b/be1-go/internal/state/subscribers.go @@ -2,6 +2,7 @@ package state import ( "encoding/json" + "github.com/rs/zerolog" "popstellar/internal/errors" "popstellar/internal/handler/jsonrpc/mjsonrpc" "popstellar/internal/handler/message/mmessage" @@ -14,11 +15,13 @@ import ( type Subscribers struct { sync.RWMutex list map[string]map[string]socket.Socket + log zerolog.Logger } -func NewSubscribers() *Subscribers { +func NewSubscribers(log zerolog.Logger) *Subscribers { return &Subscribers{ list: make(map[string]map[string]socket.Socket), + log: log.With().Str("module", "subscribers").Logger(), } }