Zap lager

cmd/broker/main.go

@@ -6,34 +6,38 @@ import (
 	"net/http"
 	"os"
 
-	"code.cloudfoundry.org/lager"
 	"github.com/pivotal-cf/brokerapi"
+	"go.uber.org/zap"
 
 	"github.com/cloudfoundry-incubator/blockhead/pkg/broker"
 	"github.com/cloudfoundry-incubator/blockhead/pkg/config"
+	"github.com/cloudfoundry-incubator/blockhead/pkg/util/logging"
 )
 
 func main() {
-	logger := lager.NewLogger("blockhead-broker")
-	logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
+	zlogger, _ := zap.NewProduction()
+	defer zlogger.Sync() // flushes buffer on exit
+	zlogger.Info("starting blockhead broker")
+
+	lag := logging.NewLagerAdapter(zlogger)
 
 	if len(os.Args) < 2 {
-		logger.Fatal("main", errors.New("config file is missing"))
+		lag.Fatal("main", errors.New("config file is missing"))
 	}
 
 	configFilepath := os.Args[1]
 	cfg, err := config.NewConfig(configFilepath)
 	if err != nil {
-		logger.Fatal("main", err)
+		lag.Fatal("main", err)
 	}
 
 	broker := broker.NewBlockheadBroker(*cfg)
 	creds := brokerapi.BrokerCredentials{
 		Username: cfg.Username,
 		Password: cfg.Password,
 	}
-	brokerAPI := brokerapi.New(broker, logger, creds)
+	brokerAPI := brokerapi.New(broker, lag, creds)
 
 	http.Handle("/", brokerAPI)
-	logger.Fatal("http-listen", http.ListenAndServe(fmt.Sprintf(":%d", cfg.Port), nil))
+	lag.Fatal("http-listen", http.ListenAndServe(fmt.Sprintf(":%d", cfg.Port), nil))
 }

pkg/util/logging/lager_adapter.go

@@ -0,0 +1,83 @@
+package logging
+
+import (
+	"fmt"
+
+	"code.cloudfoundry.org/lager"
+	"go.uber.org/zap"
+)
+
+// LagerAdapter satisfies the lager.Logger interface with zap as the
+// implementation.
+type LagerAdapter struct {
+	originalLogger *zap.Logger
+}
+
+// NewLagerAdapter returns a new lager.Logger that uses zap underneath.
+func NewLagerAdapter(zapLogger *zap.Logger) *LagerAdapter {
+	return &LagerAdapter{
+		originalLogger: zapLogger,
+	}
+}
+
+// RegisterSink is never used after initialization, so it does nothing.
+func (l *LagerAdapter) RegisterSink(_ lager.Sink) {}
+
+// Session returns a new logger with a nested session.
+func (l *LagerAdapter) Session(task string, data ...lager.Data) lager.Logger {
+	tmpLogger := l.originalLogger.Named(task)
+
+	if data != nil {
+		tmpLogger = l.originalLogger.With(dataToFields(data)...)
+	}
+
+	return &LagerAdapter{
+		originalLogger: tmpLogger,
+	}
+}
+
+// SessionName returns the name of the logger session
+func (l *LagerAdapter) SessionName() string {
+	return "why would you want the name of the logger?"
+}
+
+// Debug logs a message at the debug log level.
+func (l *LagerAdapter) Debug(action string, data ...lager.Data) {
+	l.originalLogger.Debug(action, dataToFields(data)...)
+}
+
+// Info logs a message at the info log level.
+func (l *LagerAdapter) Info(action string, data ...lager.Data) {
+	l.originalLogger.Info(action, dataToFields(data)...)
+}
+
+// Error logs a message at the error log level.
+func (l *LagerAdapter) Error(action string, err error, data ...lager.Data) {
+	l.originalLogger.Error(action, appendError(err, dataToFields(data))...)
+}
+
+// Fatal logs a message and exits with status 1.
+func (l *LagerAdapter) Fatal(action string, err error, data ...lager.Data) {
+	l.originalLogger.Fatal(action, appendError(err, dataToFields(data))...)
+}
+
+// WithData returns a logger with newly added data.
+func (l *LagerAdapter) WithData(data lager.Data) lager.Logger {
+	return &LagerAdapter{
+		originalLogger: l.originalLogger.With(dataToFields([]lager.Data{data})...),
+	}
+}
+
+func dataToFields(data []lager.Data) []zap.Field {
+	fields := []zap.Field{}
+	for _, datum := range data {
+		for key, value := range datum {
+			fields = append(fields, zap.String(key, fmt.Sprintf("%v", value)))
+		}
+	}
+	return fields
+}
+
+func appendError(err error, fields []zap.Field) []zap.Field {
+	return append(fields, zap.Error(err))
+}