Add functions to retrieve native loggers in each adapter package. (goadesign#427)

* Add functions to retrieve native loggers in each adapter package.

Also rename files from logger to adapter to better fit semantic.

* NewStdLogger => NewLogger. Add Logger function.

Author: Raphaël Simon

goagen/gen_client/generator.go

@@ -575,7 +575,7 @@ func (cmd *{{ $cmdName }}) Run(c *client.Client, args []string) error {
 {{ $default := defaultPath .Action }}{{ if $default }}	path = "{{ $default }}"
 {{ else }}	return fmt.Errorf("missing path argument")
 {{ end }}	}
-	logger := goa.NewStdLogger(log.New(os.Stderr, "", log.LstdFlags))
+	logger := goa.NewLogger(log.New(os.Stderr, "", log.LstdFlags))
 	ctx := goa.WithLogger(context.Background(), logger)
 	ws, err := c.{{ goify (printf "%s%s" .Action.Name (title .Resource.Name)) true }}(ctx, path{{/*
 	*/}}{{ $params := joinNames .Action.QueryParams }}{{ if $params }}, {{ $params }}{{ end }}{{/*
@@ -621,7 +621,7 @@ func (cmd *{{ $cmdName }}) Run(c *client.Client, args []string) error {
 {{ else }}			return fmt.Errorf("failed to deserialize payload: %s", err)
 {{ end }}		}
 	}
-{{ end }}	logger := goa.NewStdLogger(log.New(os.Stderr, "", log.LstdFlags))
+{{ end }}	logger := goa.NewLogger(log.New(os.Stderr, "", log.LstdFlags))
 	ctx := goa.WithLogger(context.Background(), logger)
 	resp, err := c.{{ goify (printf "%s%s" .Action.Name (title .Resource.Name)) true }}(ctx, path{{ if .Action.Payload }}, {{ if or .Action.Payload.Type.IsObject .Action.Payload.IsPrimitive }}&{{ end }}payload{{ else }}{{ end }}{{/*
 	*/}}{{ $params := joinNames .Action.QueryParams }}{{ if $params }}, {{ $params }}{{ end }}{{/*

goatest/testing.go

@@ -22,7 +22,7 @@ func (r ResponseSetterFunc) Encode(v interface{}) error {
 func Service(logBuf *bytes.Buffer, respSetter ResponseSetterFunc) *goa.Service {
 	s := goa.New("test")
 	logger := log.New(logBuf, "", log.Ltime)
-	s.WithLogger(goa.NewStdLogger(logger))
+	s.WithLogger(goa.NewLogger(logger))
 	s.Use(middleware.LogRequest(true))
 	s.Use(middleware.LogResponse())
 	newEncoder := func(io.Writer) goa.Encoder {

logging.go

@@ -8,101 +8,84 @@ import (
 	"golang.org/x/net/context"
 )
 
+// ErrMissingLogValue is the value used to log keys with missing values
+const ErrMissingLogValue = "MISSING"
+
 type (
 	// LogAdapter is the logger interface used by goa to log informational and error messages.
-	// Adapters to different logging backends are provided in the logging package.
+	// Adapters to different logging backends are provided in the logging sub-packages.
 	// goa takes care of initializing the logging context with the service, controller and
-	// action name. Additional logging context values may be set via WithValue.
+	// action names.
 	LogAdapter interface {
 		// Info logs an informational message.
 		Info(msg string, keyvals ...interface{})
 		// Error logs an error.
 		Error(msg string, keyvals ...interface{})
-		// New appends to the logger context and returns the updated logger adapter.
+		// New appends to the logger context and returns the updated logger logger.
 		New(keyvals ...interface{}) LogAdapter
 	}
 
-	// stdLogger uses the stdlib logger.
-	stdLogger struct {
+	// adapter is the stdlib logger adapter.
+	adapter struct {
 		*log.Logger
 		keyvals []interface{}
 	}
 )
 
-// ErrMissingLogValue is the value used to log keys with missing values
-const ErrMissingLogValue = "MISSING"
-
-// LogInfo extracts the logger from the given context and calls Info on it.
-// In general this shouldn't be needed (the client code should already have a handle on the logger)
-// This is mainly useful for "out-of-band" code like middleware.
-func LogInfo(ctx context.Context, msg string, keyvals ...interface{}) {
-	logit(ctx, msg, keyvals, false)
+// NewLogger returns a goa log adpater backed by a log logger.
+func NewLogger(logger *log.Logger) LogAdapter {
+	return &adapter{Logger: logger}
 }
 
-// LogError extracts the logger from the given context and calls Error on it.
-// In general this shouldn't be needed (the client code should already have a handle on the logger)
-// This is mainly useful for "out-of-band" code like middleware.
-func LogError(ctx context.Context, msg string, keyvals ...interface{}) {
-	logit(ctx, msg, keyvals, true)
-}
-
-func logit(ctx context.Context, msg string, keyvals []interface{}, aserror bool) {
-	if l := ctx.Value(logKey); l != nil {
-		if logger, ok := l.(LogAdapter); ok {
-			if aserror {
-				logger.Error(msg, keyvals...)
-			} else {
-				logger.Info(msg, keyvals...)
-			}
-		}
+// Logger returns the logger stored in the context if any, nil otherwise.
+func Logger(ctx context.Context) *log.Logger {
+	logger := ContextLogger(ctx)
+	if a, ok := logger.(*adapter); ok {
+		return a.Logger
 	}
+	return nil
 }
 
-// NewStdLogger returns an implementation of Logger backed by a stdlib Logger.
-func NewStdLogger(logger *log.Logger) LogAdapter {
-	return &stdLogger{Logger: logger}
-}
-
-func (l *stdLogger) Info(msg string, keyvals ...interface{}) {
-	l.logit(msg, keyvals, false)
+func (a *adapter) Info(msg string, keyvals ...interface{}) {
+	a.logit(msg, keyvals, false)
 }
 
-func (l *stdLogger) Error(msg string, keyvals ...interface{}) {
-	l.logit(msg, keyvals, true)
+func (a *adapter) Error(msg string, keyvals ...interface{}) {
+	a.logit(msg, keyvals, true)
 }
 
-func (l *stdLogger) New(keyvals ...interface{}) LogAdapter {
+func (a *adapter) New(keyvals ...interface{}) LogAdapter {
 	if len(keyvals) == 0 {
-		return l
+		return a
 	}
-	kvs := append(l.keyvals, keyvals...)
+	kvs := append(a.keyvals, keyvals...)
 	if len(kvs)%2 != 0 {
 		kvs = append(kvs, ErrMissingLogValue)
 	}
-	return &stdLogger{
-		Logger: l.Logger,
+	return &adapter{
+		Logger: a.Logger,
 		// Limiting the capacity of the stored keyvals ensures that a new
 		// backing array is created if the slice must grow.
 		keyvals: kvs[:len(kvs):len(kvs)],
 	}
 }
 
-func (l *stdLogger) logit(msg string, keyvals []interface{}, iserror bool) {
+func (a *adapter) logit(msg string, keyvals []interface{}, iserror bool) {
 	n := (len(keyvals) + 1) / 2
 	if len(keyvals)%2 != 0 {
 		keyvals = append(keyvals, ErrMissingLogValue)
 	}
 	var fm bytes.Buffer
 	lvl := "INFO"
 	if iserror {
-		lvl = "ERROR"
+		lvl = "EROR"
 	}
 	fm.WriteString(fmt.Sprintf("[%s] %s", lvl, msg))
 	vals := make([]interface{}, n)
-	offset := len(l.keyvals)
+	offset := len(a.keyvals)
 	for i := 0; i < offset; i += 2 {
-		k := l.keyvals[i]
-		v := l.keyvals[i+1]
+		k := a.keyvals[i]
+		v := a.keyvals[i+1]
 		vals[i/2] = v
 		fm.WriteString(fmt.Sprintf(" %s=%%+v", k))
 	}
@@ -112,5 +95,27 @@ func (l *stdLogger) logit(msg string, keyvals []interface{}, iserror bool) {
 		vals[i/2+offset/2] = v
 		fm.WriteString(fmt.Sprintf(" %s=%%+v", k))
 	}
-	l.Logger.Printf(fm.String(), vals...)
+	a.Logger.Printf(fm.String(), vals...)
+}
+
+// LogInfo extracts the logger from the given context and calls Info on it.
+// This is intended for code that needs portable logging such as the internal code of goa and
+// middleware. User code should use the log adapters instead.
+func LogInfo(ctx context.Context, msg string, keyvals ...interface{}) {
+	if l := ctx.Value(logKey); l != nil {
+		if logger, ok := l.(LogAdapter); ok {
+			logger.Info(msg, keyvals...)
+		}
+	}
+}
+
+// LogError extracts the logger from the given context and calls Error on it.
+// This is intended for code that needs portable logging such as the internal code of goa and
+// middleware. User code should use the log adapters instead.
+func LogError(ctx context.Context, msg string, keyvals ...interface{}) {
+	if l := ctx.Value(logKey); l != nil {
+		if logger, ok := l.(LogAdapter); ok {
+			logger.Error(msg, keyvals...)
+		}
+	}
 }

logging/doc.go

@@ -1,6 +1,7 @@
 /*
 Package logging contains logger adapters that make it possible for goa to log messages to various
-logger backends. Each adapter exists in its own package named after the corresponding logger package.
+logger backends. Each adapter exists in its own sub-package named after the corresponding logger
+package.
 
 Once instantiated adapters can be used by setting the goa service logger with WithLogger:
 
@@ -18,5 +19,7 @@ Once instantiated adapters can be used by setting the goa service logger with Wi
     // ...
 }
 ```
+
+See http://goa.design/implement/logging/ for details.
 */
 package logging

logging/kit/logger.go logging/kit/adapter.go

@@ -8,16 +8,20 @@ Usage:
     // Initialize goa service logger using adapter
     service.WithLogger(goakit.New(logger))
     // ... Proceed with configuring and starting the goa service
+
+    // In handlers:
+    goakit.Context(ctx).Log("foo", "bar")
 */
 package goakit
 
 import (
 	"github.com/go-kit/kit/log"
 	"github.com/goadesign/goa"
+	"golang.org/x/net/context"
 )
 
-// Logger is the go-kit log goa adapter logger.
-type Logger struct {
+// adapter is the go-kit log goa logger adapter.
+type adapter struct {
 	*log.Context
 }
 
@@ -28,24 +32,33 @@ func New(logger log.Logger) goa.LogAdapter {
 
 // FromContext wraps a go-kit log context into a goa logger.
 func FromContext(ctx *log.Context) goa.LogAdapter {
-	return &Logger{Context: ctx}
+	return &adapter{Context: ctx}
+}
+
+// Context returns the go-kit log context stored in the given context if any, nil otherwise.
+func Context(ctx context.Context) *log.Context {
+	logger := goa.ContextLogger(ctx)
+	if a, ok := logger.(*adapter); ok {
+		return a.Context
+	}
+	return nil
 }
 
 // Info logs informational messages using go-kit.
-func (l *Logger) Info(msg string, data ...interface{}) {
+func (a *adapter) Info(msg string, data ...interface{}) {
 	ctx := []interface{}{"lvl", "info", "msg", msg}
 	ctx = append(ctx, data...)
-	l.Context.Log(ctx...)
+	a.Context.Log(ctx...)
 }
 
 // Error logs error messages using go-kit.
-func (l *Logger) Error(msg string, data ...interface{}) {
+func (a *adapter) Error(msg string, data ...interface{}) {
 	ctx := []interface{}{"lvl", "error", "msg", msg}
 	ctx = append(ctx, data...)
-	l.Context.Log(ctx...)
+	a.Context.Log(ctx...)
 }
 
 // New instantiates a new logger from the given context.
-func (l *Logger) New(data ...interface{}) goa.LogAdapter {
-	return &Logger{Context: l.Context.With(data...)}
+func (a *adapter) New(data ...interface{}) goa.LogAdapter {
+	return &adapter{Context: a.Context.With(data...)}
 }

logging/kit/adapter_test.go

@@ -0,0 +1,60 @@
+package goakit_test
+
+import (
+	"bytes"
+
+	"golang.org/x/net/context"
+
+	"github.com/go-kit/kit/log"
+	"github.com/goadesign/goa"
+	"github.com/goadesign/goa/logging/kit"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("New", func() {
+	var buf bytes.Buffer
+	var logger log.Logger
+	var adapter goa.LogAdapter
+
+	BeforeEach(func() {
+		logger = log.NewLogfmtLogger(&buf)
+		adapter = goakit.New(logger)
+	})
+
+	It("creates an adapter that logs", func() {
+		msg := "msg"
+		adapter.Info(msg)
+		Ω(buf.String()).Should(Equal("lvl=info msg=" + msg + "\n"))
+	})
+})
+
+var _ = Describe("FromContext", func() {
+	var buf bytes.Buffer
+	var logctx *log.Context
+	var adapter goa.LogAdapter
+
+	BeforeEach(func() {
+		logger := log.NewLogfmtLogger(&buf)
+		logctx = log.NewContext(logger)
+		adapter = goakit.FromContext(logctx)
+	})
+
+	It("creates an adapter that logs", func() {
+		msg := "msg"
+		adapter.Info(msg)
+		Ω(buf.String()).Should(Equal("lvl=info msg=" + msg + "\n"))
+	})
+
+	Context("Context", func() {
+		var ctx context.Context
+
+		BeforeEach(func() {
+			ctx = goa.WithLogger(context.Background(), adapter)
+		})
+
+		It("extracts the log context", func() {
+			Ω(goakit.Context(ctx)).Should(Equal(logctx))
+		})
+	})
+})