Change Logger to resemble go-kit/log.Logger

.golangci.yml

@@ -0,0 +1,6 @@
+linters-settings:
+  errcheck:
+    exclude-functions:
+      - (io.Writer).Write
+      - (github.com/stephenafamo/orchestra.Logger).Log
+

conductor.go

@@ -76,10 +76,10 @@ func (c *Conductor) playWithLogger(ctx context.Context, logger Logger) error {
 	case err := <-errs:
 		return fmt.Errorf("error occured in a player: %w", err)
 	case <-timedCtx.Done():
-		logger.Printf("conductor stopped after timeout")
+		logger.Log("msg", "conductor stopped after timeout")
 		return c.getTimeoutError(&lock)
 	case <-allDone:
-		logger.Printf("conductor exited sucessfully")
+		logger.Log("msg", "conductor exited sucessfully")
 		return nil
 	}
 }
@@ -97,7 +97,7 @@ func (c *Conductor) conductPlayer(ctx context.Context, wg *sync.WaitGroup, lock
 		c.playing[name] = struct{}{}
 		lock.Unlock()
 
-		l.Printf("starting %q", name)
+		l.Log("msg", "starting player", "name", name)
 
 		var err error
 		if c, ok := p.(*Conductor); ok {
@@ -110,10 +110,10 @@ func (c *Conductor) conductPlayer(ctx context.Context, wg *sync.WaitGroup, lock
 		}
 
 		if err != nil {
-			DefaultLogger.Printf("error in %q", name)
+			DefaultLogger.Log("error in " + name)
 			errs <- InstrumentError{name, err}
 		}
-		l.Printf("stopped %q", name)
+		l.Log("msg", "stopped player", "name", name)
 	}
 
 	lock.Lock()

player.go

@@ -13,16 +13,8 @@ type Player interface {
 
 // PlayUntilSignal starts the player and stops when it recieves os.Signals
 func PlayUntilSignal(p Player, sig ...os.Signal) error {
-
-	signals := make(chan os.Signal)
-	ctx, cancel := context.WithCancel(context.Background())
-	signal.Notify(signals, sig...)
-
-	// cancel the context if we receive a SIGINT or SIGTERM
-	go func() {
-		<-signals
-		cancel()
-	}()
+	ctx, cancel := signal.NotifyContext(context.Background(), sig...)
+	defer cancel()
 
 	return p.Play(ctx)
 }

server.go

@@ -9,17 +9,13 @@ import (
 
 // ServerPlayer is a type that extends the *http.Server
 type ServerPlayer struct {
-	Logger Logger
 	*http.Server
 }
 
 // Play starts the server until the context is done
 func (s ServerPlayer) Play(ctxMain context.Context) error {
 	errChan := make(chan error, 1)
 	go func() {
-		if s.Logger != nil {
-			s.Logger.Printf("starting server")
-		}
 		if err := s.ListenAndServe(); err != nil {
 			if err != http.ErrServerClosed {
 				errChan <- fmt.Errorf("error: failed to start server: %w", err)
@@ -30,10 +26,6 @@ func (s ServerPlayer) Play(ctxMain context.Context) error {
 
 	select {
 	case <-ctxMain.Done():
-		if s.Logger != nil {
-			s.Logger.Printf("shutting down server")
-		}
-
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
@@ -42,9 +34,6 @@ func (s ServerPlayer) Play(ctxMain context.Context) error {
 			return fmt.Errorf("error while shutting down server: %v", err)
 		}
 
-		if s.Logger != nil {
-			s.Logger.Printf("shut down successfully")
-		}
 		return nil
 
 	case err := <-errChan:

types.go

@@ -1,28 +1,51 @@
 package orchestra
 
 import (
-	"log"
-	"os"
+	"errors"
+	"fmt"
 )
 
 // Logger is accepted by some Players ([Conductor], [ServerPlayer])
 type Logger interface {
-	Printf(format string, v ...interface{})
+	Log(keyvals ...interface{}) error
 }
 
 // DefaultLogger is used when a conductor's logger is nil
-var DefaultLogger Logger = log.New(os.Stderr, "", log.LstdFlags)
+var DefaultLogger Logger = defaultLogger{}
+
+type defaultLogger struct{}
+
+func (d defaultLogger) Log(keyvals ...interface{}) error {
+	pairLen := len(keyvals)
+
+	if pairLen < 1 || pairLen%2 != 0 {
+		return errors.New("non-even number of values to log")
+	}
+
+	for i := range keyvals {
+		if i%2 != 0 {
+			continue
+		}
+
+		fmt.Printf("%v=%q ", keyvals[i], keyvals[i+1])
+	}
+
+	// Move to next line
+	fmt.Println()
+
+	return nil
+}
 
 type subConductorLogger struct {
 	name string
 	l    Logger
 }
 
-func (s subConductorLogger) Printf(format string, v ...interface{}) {
+func (s subConductorLogger) Log(keyvals ...interface{}) error {
 	l := s.l
 	if s.l == nil {
 		l = DefaultLogger
 	}
 
-	l.Printf("%s: "+format, append([]interface{}{s.name}, v...)...)
+	return l.Log(append([]interface{}{"conductor", s.name}, keyvals...)...)
 }