fix: remove global logger (#9)

fix: remove global logger

.gitignore

@@ -22,4 +22,6 @@ go.work
 
 # Generated dependencies and cache
 third_party
-nimcache
+nimcache
+
+.idea

go.mod

@@ -3,6 +3,7 @@ module github.com/waku-org/sds-go-bindings
 go 1.24.0
 
 require (
+	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.8.1
 	go.uber.org/zap v1.27.0
 )

go.sum

@@ -1,6 +1,8 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

sds/logging.go

@@ -1,47 +0,0 @@
-package sds
-
-import (
-	"sync"
-
-	"go.uber.org/zap"
-)
-
-var (
-	once  sync.Once
-	sugar *zap.SugaredLogger
-)
-
-func _getLogger() *zap.SugaredLogger {
-	once.Do(func() {
-
-		config := zap.NewDevelopmentConfig()
-		l, err := config.Build()
-		if err != nil {
-			panic(err)
-		}
-		sugar = l.Sugar()
-	})
-	return sugar
-}
-
-func SetLogger(newLogger *zap.Logger) {
-	once.Do(func() {})
-
-	sugar = newLogger.Sugar()
-}
-
-func Debug(msg string, args ...interface{}) {
-	_getLogger().Debugf(msg, args...)
-}
-
-func Info(msg string, args ...interface{}) {
-	_getLogger().Infof(msg, args...)
-}
-
-func Warn(msg string, args ...interface{}) {
-	_getLogger().Warnf(msg, args...)
-}
-
-func Error(msg string, args ...interface{}) {
-	_getLogger().Errorf(msg, args...)
-}

sds/sds.go

@@ -136,6 +136,13 @@ import (
 	"strings"
 	"sync"
 	"unsafe"
+
+	errorspkg "github.com/pkg/errors"
+	"go.uber.org/zap"
+)
+
+var (
+	errEmptyReliabilityManager = errors.New("empty reliability manager")
 )
 
 //export SdsGoCallback
@@ -150,9 +157,16 @@ func SdsGoCallback(ret C.int, msg *C.char, len C.size_t, resp unsafe.Pointer) {
 	}
 }
 
-func NewReliabilityManager() (*ReliabilityManager, error) {
+func NewReliabilityManager(logger *zap.Logger) (*ReliabilityManager, error) {
-	Debug("Creating new Reliability Manager")
+	if logger == nil {
-	rm := &ReliabilityManager{}
+		logger = zap.NewNop()
+	}
+
+	rm := &ReliabilityManager{
+		logger: logger,
+	}
+
+	rm.logger.Info("creating new reliability manager")
 
 	wg := sync.WaitGroup{}
 
@@ -161,7 +175,6 @@ func NewReliabilityManager() (*ReliabilityManager, error) {
 
 	if C.getRet(resp) != C.RET_OK {
 		errMsg := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-		Error("error NewReliabilityManager: %v", errMsg)
 		return nil, errors.New(errMsg)
 	}
 
@@ -172,36 +185,31 @@ func NewReliabilityManager() (*ReliabilityManager, error) {
 	C.cGoSdsSetEventCallback(rm.rmCtx)
 	registerReliabilityManager(rm)
 
-	Debug("Successfully created Reliability Manager")
+	rm.logger.Debug("successfully created reliability manager")
 	return rm, nil
 }
 
 //export sdsGlobalEventCallback
 func sdsGlobalEventCallback(callerRet C.int, msg *C.char, len C.size_t, userData unsafe.Pointer) {
+	msgStr := C.GoStringN(msg, C.int(len))
+	rm, ok := rmRegistry[userData] // userData contains rm's ctx
+	if !ok {
+		return
+	}
+
 	if callerRet == C.RET_OK {
-		eventStr := C.GoStringN(msg, C.int(len))
+		rm.OnEvent(msgStr)
-		rm, ok := rmRegistry[userData] // userData contains rm's ctx
-		if ok {
-			rm.OnEvent(eventStr)
-		}
 	} else {
-		if len != 0 {
+		rm.OnCallbackError(int(callerRet), msgStr)
-			errMsg := C.GoStringN(msg, C.int(len))
-			Error("sdsGlobalEventCallback retCode not ok, retCode: %v: %v", callerRet, errMsg)
-		} else {
-			Error("sdsGlobalEventCallback retCode not ok, retCode: %v", callerRet)
-		}
 	}
 }
 
 func (rm *ReliabilityManager) Cleanup() error {
 	if rm == nil {
-		err := errors.New("reliability manager is nil in Cleanup")
+		return errEmptyReliabilityManager
-		Error("Failed to cleanup %v", err)
-		return err
 	}
 
-	Debug("Cleaning up reliability manager")
+	rm.logger.Debug("cleaning up reliability manager")
 
 	wg := sync.WaitGroup{}
 	var resp = C.allocResp(unsafe.Pointer(&wg))
@@ -213,24 +221,20 @@ func (rm *ReliabilityManager) Cleanup() error {
 
 	if C.getRet(resp) == C.RET_OK {
 		unregisterReliabilityManager(rm)
-		Debug("Successfully cleaned up reliability manager")
+		rm.logger.Debug("cleaned up reliability manager")
 		return nil
 	}
 
 	errMsg := "error CleanupReliabilityManager: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	Error("Failed to cleanup reliability manager: %v", errMsg)
-
 	return errors.New(errMsg)
 }
 
 func (rm *ReliabilityManager) Reset() error {
 	if rm == nil {
-		err := errors.New("reliability manager is nil in Reset")
+		return errEmptyReliabilityManager
-		Error("Failed to reset %v", err)
-		return err
 	}
 
-	Debug("Resetting reliability manager")
+	rm.logger.Debug("resetting reliability manager")
 
 	wg := sync.WaitGroup{}
 	var resp = C.allocResp(unsafe.Pointer(&wg))
@@ -241,24 +245,21 @@ func (rm *ReliabilityManager) Reset() error {
 	wg.Wait()
 
 	if C.getRet(resp) == C.RET_OK {
-		Debug("Successfully resetted reliability manager")
+		rm.logger.Debug("successfully resetted reliability manager")
 		return nil
 	}
 
 	errMsg := "error ResetReliabilityManager: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	Error("Failed to reset reliability manager: %v", errMsg)
-
 	return errors.New(errMsg)
 }
 
 func (rm *ReliabilityManager) WrapOutgoingMessage(message []byte, messageId MessageID, channelId string) ([]byte, error) {
 	if rm == nil {
-		err := errors.New("reliability manager is nil in WrapOutgoingMessage")
+		return nil, errEmptyReliabilityManager
-		Error("Failed to wrap outgoing message %v", err)
-		return nil, err
 	}
 
-	Debug("Wrapping outgoing message %v", messageId)
+	logger := rm.logger.With(zap.String("messageId", string(messageId)))
+	logger.Debug("wrapping outgoing message", zap.String("messageId", string(messageId)))
 
 	wg := sync.WaitGroup{}
 	var resp = C.allocResp(unsafe.Pointer(&wg))
@@ -286,10 +287,10 @@ func (rm *ReliabilityManager) WrapOutgoingMessage(message []byte, messageId Mess
 	if C.getRet(resp) == C.RET_OK {
 		resStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
 		if resStr == "" {
-			Debug("Received empty res string for messageId: %v", messageId)
+			logger.Debug("received empty res string for messageId")
 			return nil, nil
 		}
-		Debug("Successfully wrapped message %s", messageId)
+		logger.Debug("successfully wrapped message")
 
 		parts := strings.Split(resStr, ",")
 		bytes := make([]byte, len(parts))
@@ -306,16 +307,12 @@ func (rm *ReliabilityManager) WrapOutgoingMessage(message []byte, messageId Mess
 	}
 
 	errMsg := "error WrapOutgoingMessage: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	Error("Failed to wrap message %v: %v", messageId, errMsg)
-
 	return nil, errors.New(errMsg)
 }
 
 func (rm *ReliabilityManager) UnwrapReceivedMessage(message []byte) (*UnwrappedMessage, error) {
 	if rm == nil {
-		err := errors.New("reliability manager is nil in UnwrapReceivedMessage")
+		return nil, errEmptyReliabilityManager
-		Error("Failed to unwrap received message %v", err)
-		return nil, err
 	}
 
 	wg := sync.WaitGroup{}
@@ -338,33 +335,28 @@ func (rm *ReliabilityManager) UnwrapReceivedMessage(message []byte) (*UnwrappedM
 	if C.getRet(resp) == C.RET_OK {
 		resStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
 		if resStr == "" {
-			Debug("Received empty res string")
+			rm.logger.Debug("received empty res string")
 			return nil, nil
 		}
-		Debug("Successfully unwrapped message")
+		rm.logger.Debug("successfully unwrapped message")
 
 		unwrappedMessage := UnwrappedMessage{}
 		err := json.Unmarshal([]byte(resStr), &unwrappedMessage)
 		if err != nil {
-			Error("Failed to unmarshal unwrapped message")
+			return nil, errorspkg.Wrap(err, "failed to unmarshal unwrapped message")
-			return nil, err
 		}
 
 		return &unwrappedMessage, nil
 	}
 
 	errMsg := "error UnwrapReceivedMessage: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	Error("Failed to unwrap message: %v", errMsg)
-
 	return nil, errors.New(errMsg)
 }
 
 // MarkDependenciesMet informs the library that dependencies are met
 func (rm *ReliabilityManager) MarkDependenciesMet(messageIDs []MessageID, channelId string) error {
 	if rm == nil {
-		err := errors.New("reliability manager is nil in MarkDependenciesMet")
+		return errEmptyReliabilityManager
-		Error("Failed to mark dependencies met %v", err)
-		return err
 	}
 
 	if len(messageIDs) == 0 {
@@ -399,24 +391,20 @@ func (rm *ReliabilityManager) MarkDependenciesMet(messageIDs []MessageID, channe
 	wg.Wait()
 
 	if C.getRet(resp) == C.RET_OK {
-		Debug("Successfully marked dependencies as met")
+		rm.logger.Debug("successfully marked dependencies as met")
 		return nil
 	}
 
 	errMsg := "error MarkDependenciesMet: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	Error("Failed to mark dependencies as met: %v", errMsg)
-
 	return errors.New(errMsg)
 }
 
 func (rm *ReliabilityManager) StartPeriodicTasks() error {
 	if rm == nil {
-		err := errors.New("reliability manager is nil in StartPeriodicTasks")
+		return errEmptyReliabilityManager
-		Error("Failed to start periodic tasks %v", err)
-		return err
 	}
 
-	Debug("Starting periodic tasks")
+	rm.logger.Debug("starting periodic tasks")
 
 	wg := sync.WaitGroup{}
 	var resp = C.allocResp(unsafe.Pointer(&wg))
@@ -427,12 +415,10 @@ func (rm *ReliabilityManager) StartPeriodicTasks() error {
 	wg.Wait()
 
 	if C.getRet(resp) == C.RET_OK {
-		Debug("Successfully started periodic tasks")
+		rm.logger.Debug("successfully started periodic tasks")
 		return nil
 	}
 
 	errMsg := "error StartPeriodicTasks: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	Error("Failed to start periodic tasks: %v", errMsg)
-
 	return errors.New(errMsg)
 }

sds/sds_common.go

@@ -4,6 +4,8 @@ import (
 	"encoding/json"
 	"time"
 	"unsafe"
+
+	"go.uber.org/zap"
 )
 
 const requestTimeout = 30 * time.Second
@@ -18,6 +20,7 @@ type EventCallbacks struct {
 
 // ReliabilityManager represents an instance of a nim-sds ReliabilityManager
 type ReliabilityManager struct {
+	logger    *zap.Logger
 	rmCtx     unsafe.Pointer
 	callbacks EventCallbacks
 }
@@ -67,7 +70,7 @@ func (rm *ReliabilityManager) OnEvent(eventStr string) {
 	jsonEvent := jsonEvent{}
 	err := json.Unmarshal([]byte(eventStr), &jsonEvent)
 	if err != nil {
-		Error("could not unmarshal sds event string: %v", err)
+		rm.logger.Error("failed to unmarshal sds event string", zap.Error(err))
 		return
 	}
 
@@ -85,11 +88,17 @@ func (rm *ReliabilityManager) OnEvent(eventStr string) {
 	}
 }
 
+func (rm *ReliabilityManager) OnCallbackError(callerRet int, err string) {
+	rm.logger.Error("sds callback error",
+		zap.Int("retCode", callerRet),
+		zap.String("errMsg", err))
+}
+
 func (rm *ReliabilityManager) parseMessageReadyEvent(eventStr string) {
 	msgEvent := msgEvent{}
 	err := json.Unmarshal([]byte(eventStr), &msgEvent)
 	if err != nil {
-		Error("could not parse message ready event %v", err)
+		rm.logger.Error("failed to parse message ready event", zap.Error(err))
 	}
 
 	if rm.callbacks.OnMessageReady != nil {
@@ -101,7 +110,8 @@ func (rm *ReliabilityManager) parseMessageSentEvent(eventStr string) {
 	msgEvent := msgEvent{}
 	err := json.Unmarshal([]byte(eventStr), &msgEvent)
 	if err != nil {
-		Error("could not parse message sent event %v", err)
+		rm.logger.Error("failed to parse message sent event", zap.Error(err))
+		return
 	}
 
 	if rm.callbacks.OnMessageSent != nil {
@@ -113,7 +123,8 @@ func (rm *ReliabilityManager) parseMissingDepsEvent(eventStr string) {
 	missingDepsEvent := missingDepsEvent{}
 	err := json.Unmarshal([]byte(eventStr), &missingDepsEvent)
 	if err != nil {
-		Error("could not parse missing dependencies event %v", err)
+		rm.logger.Error("failed to parse missing dependencies event", zap.Error(err))
+		return
 	}
 
 	if rm.callbacks.OnMissingDependencies != nil {

sds/sds_lint.go

@@ -2,7 +2,11 @@
 
 package sds
 
-import "errors"
+import (
+	"errors"
+
+	"go.uber.org/zap"
+)
 
 // This file provides lint-only stubs that avoid requiring libsds.h/cgo
 // so linters can analyze this package without native dependencies.
@@ -11,8 +15,8 @@ import "errors"
 var ErrLintBuild = errors.New("sds: lint-only build stub: native libsds not linked")
 
 // NewReliabilityManager returns an error in lint builds.
-func NewReliabilityManager() (*ReliabilityManager, error) {
+func NewReliabilityManager(logger *zap.Logger) (*ReliabilityManager, error) {
-    return nil, ErrLintBuild
+	return nil, ErrLintBuild
 }
 
 // Cleanup returns an error in lint builds.
@@ -23,16 +27,18 @@ func (rm *ReliabilityManager) Reset() error { return ErrLintBuild }
 
 // WrapOutgoingMessage returns an error in lint builds.
 func (rm *ReliabilityManager) WrapOutgoingMessage(message []byte, messageId MessageID, channelId string) ([]byte, error) {
-    return nil, ErrLintBuild
+	return nil, ErrLintBuild
 }
 
 // UnwrapReceivedMessage returns an error in lint builds.
 func (rm *ReliabilityManager) UnwrapReceivedMessage(message []byte) (*UnwrappedMessage, error) {
-    return nil, ErrLintBuild
+	return nil, ErrLintBuild
 }
 
 // MarkDependenciesMet returns an error in lint builds.
-func (rm *ReliabilityManager) MarkDependenciesMet(messageIDs []MessageID, channelId string) error { return ErrLintBuild }
+func (rm *ReliabilityManager) MarkDependenciesMet(messageIDs []MessageID, channelId string) error {
+	return ErrLintBuild
+}
 
 // StartPeriodicTasks returns an error in lint builds.
 func (rm *ReliabilityManager) StartPeriodicTasks() error { return ErrLintBuild }