Cleanup middlewares.

Author: raphael

.golint_exclude

@@ -1,3 +1,4 @@
 http/design/response.go
 ^examples/.*
 http/codegen/testing/.*
+http/middleware/tracing/middleware.go

examples/cellar/cmd/cellarsvc/main.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/boltdb/bolt"
 
-	goa "goa.design/goa"
 	cellar "goa.design/goa/examples/cellar"
 	sommeliersvr "goa.design/goa/examples/cellar/gen/http/sommelier/server"
 	storagesvr "goa.design/goa/examples/cellar/gen/http/storage/server"
@@ -38,11 +37,11 @@ func main() {
 	// packages is very simple as well.
 	var (
 		logger  *log.Logger
-		adapter goa.LogAdapter
+		adapter logging.Adapter
 	)
 	{
 		logger = log.New(os.Stderr, "[cellar] ", log.Ltime)
-		adapter = goa.AdaptStdLogger(logger)
+		adapter = logging.Adapt(logger)
 	}
 
 	// Initialize service dependencies such as databases.

http/codegen/example_server.go

@@ -135,16 +135,15 @@ const mainT = `func main() {
 	flag.Parse()
 
 	// Setup logger and goa log adapter. Replace logger with your own using
-	// your log package of choice. The goa.design/logging package defines
-	// log adapters for common log packages. Writing adapters for other log
-	// packages is very simple as well.
+	// your log package of choice. The goa.design/middleware/logging/...
+	// packages define log adapters for common log packages.
 	var (
 		logger  *log.Logger
-		adapter goa.LogAdapter
+		adapter logging.Adapter
 	)
 	{
 		logger = log.New(os.Stderr, "[{{ .APIPkg }}] ", log.Ltime)
-		adapter = goa.AdaptStdLogger(logger)
+		adapter = logging.Adapt(logger)
 	}
 
 	// Create the structs that implement the services.

http/middleware/debugging/middleware.go

@@ -9,9 +9,8 @@ import (
 	"net/http"
 	"strings"
 
-	goa "goa.design/goa"
 	goahttp "goa.design/goa/http"
-	"goa.design/goa/http/middleware/tracing"
+	"goa.design/goa/http/middleware/logging"
 )
 
 // responseDupper tees the response to a buffer and a response writer.
@@ -23,14 +22,10 @@ type responseDupper struct {
 
 // New returns a debug middleware which logs all the details about incoming
 // requests and outgoing responses.
-func New(mux goahttp.Muxer, logger goa.LogAdapter) func(http.Handler) http.Handler {
+func New(mux goahttp.Muxer, logger logging.Adapter) func(http.Handler) http.Handler {
 	return func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			requestID := tracing.ContextTraceID(r.Context())
-			if requestID == "" {
-				requestID = shortID()
-			}
-
+			requestID := shortID()
 			if len(r.Header) > 0 {
 				entries := make([]interface{}, 4+2*len(r.Header))
 				entries[0] = "id"

http/middleware/logging/adapter.go

@@ -0,0 +1,51 @@
+package logging
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log"
+)
+
+type (
+	// Adapter is the logging interface used by the middleware to produce
+	// log entries.
+	Adapter interface {
+		// Info logs informational messages.
+		Info(ctx context.Context, keyvals ...interface{})
+		// Error logs error messages.
+		Error(ctx context.Context, keyvals ...interface{})
+	}
+
+	// adapter is a thin wrapper around the stdlib logger that adapts it to
+	// the Adapter interface.
+	adapter struct {
+		*log.Logger
+	}
+)
+
+// Adapt creates a Adapter backed by a stdlib logger.
+func Adapt(l *log.Logger) Adapter {
+	return &adapter{l}
+}
+
+func (a *adapter) Info(_ context.Context, keyvals ...interface{})  { a.log("INFO", keyvals...) }
+func (a *adapter) Error(_ context.Context, keyvals ...interface{}) { a.log("ERROR", keyvals...) }
+
+func (a *adapter) log(lvl string, keyvals ...interface{}) {
+	n := (len(keyvals) + 1) / 2
+	if len(keyvals)%2 != 0 {
+		keyvals = append(keyvals, "MISSING")
+	}
+	var fm bytes.Buffer
+	fm.WriteString("[%s]")
+	vals := make([]interface{}, n+1)
+	vals[0] = lvl
+	for i := 0; i < len(keyvals); i += 2 {
+		k := keyvals[i]
+		v := keyvals[i+1]
+		vals[i/2+1] = v
+		fm.WriteString(fmt.Sprintf(" %s=%%+v", k))
+	}
+	a.Logger.Printf(fm.String(), vals...)
+}

http/middleware/logging/middleware.go

@@ -7,31 +7,25 @@ import (
 	"net"
 	"net/http"
 	"time"
-
-	"goa.design/goa"
-	"goa.design/goa/http/middleware/tracing"
 )
 
 // New returns a middleware that logs short messages for incoming requests and
 // outgoing responses.
-func New(logger goa.LogAdapter) func(h http.Handler) http.Handler {
+func New(a Adapter) func(h http.Handler) http.Handler {
 	return func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			reqID := tracing.ContextTraceID(r.Context())
-			if reqID == "" {
-				reqID = shortID()
-			}
+			reqID := shortID()
 			started := time.Now()
 
-			logger.Info(r.Context(),
+			a.Info(r.Context(),
 				"id", reqID,
-				r.Method, r.URL.String(),
+				"req", r.Method+" "+r.URL.String(),
 				"from", from(r))
 
 			rw := CaptureResponse(w)
 			h.ServeHTTP(rw, r)
 
-			logger.Info(r.Context(),
+			a.Info(r.Context(),
 				"id", reqID,
 				"status", rw.StatusCode,
 				"bytes", rw.ContentLength,

http/middleware/tracing/middleware.go

@@ -7,18 +7,20 @@ import (
 	"io"
 	"net/http"
 
-	"goa.design/goa"
+	"goa.design/goa/http/middleware/logging"
 )
 
-// middlewareKey is the private type used for goa middlewares to store values in
-// the context. It is private to avoid possible collisions with keys used by
-// other packages.
-type middlewareKey int
-
 const (
-	traceKey middlewareKey = iota + 1
-	spanKey
-	parentSpanKey
+	// TraceIDKey is the request context key used to store its Trace ID if any.
+	TraceIDKey = "TraceIDCtxKey"
+
+	// TraceSpanIDKey is the request context key used to store the current
+	// trace span ID if any.
+	TraceSpanIDKey = "TraceSpanIDCtxKey"
+
+	// TraceParentSpanIDKey is the request context key used to store the current
+	// trace parent span ID if any.
+	TraceParentSpanIDKey = "TraceParentSpanIDCtxKey"
 )
 
 const (
@@ -45,16 +47,16 @@ type (
 	// the middleware.
 	Option func(*options) *options
 
-	// tracedDoer is a client Doer that inserts the tracing headers for
-	// each request it makes.
+	// tracedDoer is a client Doer that inserts the tracing headers for each
+	// request it makes.
 	tracedDoer struct {
 		Doer
 	}
 
-	// tracedLogger is a logger which logs the trace ID with every log
-	// entry when one is present.
+	// tracedLogger is a logger which logs the trace ID with every log entry
+	// when one is present.
 	tracedLogger struct {
-		goa.LogAdapter
+		logging.Adapter
 	}
 
 	// options is the struct storing all the options.
@@ -185,88 +187,61 @@ func WrapDoer(ctx context.Context, doer Doer) Doer {
 
 // WrapLogger returns a logger which logs the trace ID with every message if
 // there is one.
-func WrapLogger(l goa.LogAdapter) goa.LogAdapter {
+func WrapLogger(l logging.Adapter) logging.Adapter {
 	return &tracedLogger{l}
 }
 
-// ContextTraceID returns the trace ID extracted from the given context if any,
-// the empty string otherwise.
-func ContextTraceID(ctx context.Context) string {
-	if t := ctx.Value(traceKey); t != nil {
-		return t.(string)
-	}
-	return ""
-}
-
-// ContextSpanID returns the span ID extracted from the given context if any,
-// the empty string otherwise.
-func ContextSpanID(ctx context.Context) string {
-	if s := ctx.Value(spanKey); s != nil {
-		return s.(string)
-	}
-	return ""
-}
-
-// ContextParentSpanID returns the parent span ID extracted from the given
-// context if any, the empty string otherwise.
-func ContextParentSpanID(ctx context.Context) string {
-	if p := ctx.Value(parentSpanKey); p != nil {
-		return p.(string)
-	}
-	return ""
-}
-
 // WithTrace returns a context containing the given trace ID.
 func WithTrace(ctx context.Context, traceID string) context.Context {
-	ctx = context.WithValue(ctx, traceKey, traceID)
+	ctx = context.WithValue(ctx, TraceIDKey, traceID)
 	return ctx
 }
 
 // WithSpan returns a context containing the given trace, span and parent span
 // IDs.
 func WithSpan(ctx context.Context, traceID, spanID, parentID string) context.Context {
 	if parentID != "" {
-		ctx = context.WithValue(ctx, parentSpanKey, parentID)
+		ctx = context.WithValue(ctx, TraceParentSpanIDKey, parentID)
 	}
-	ctx = context.WithValue(ctx, traceKey, traceID)
-	ctx = context.WithValue(ctx, spanKey, spanID)
+	ctx = context.WithValue(ctx, TraceIDKey, traceID)
+	ctx = context.WithValue(ctx, TraceSpanIDKey, spanID)
 	return ctx
 }
 
 // Do adds the tracing headers to the requests before making it.
 func (d *tracedDoer) Do(r *http.Request) (*http.Response, error) {
 	var (
-		traceID = ContextTraceID(r.Context())
-		spanID  = ContextSpanID(r.Context())
+		traceID = r.Context().Value(TraceIDKey)
+		spanID  = r.Context().Value(TraceSpanIDKey)
 	)
-	if traceID != "" {
-		r.Header.Set(TraceIDHeader, traceID)
-		r.Header.Set(ParentSpanIDHeader, spanID)
+	if traceID != nil {
+		r.Header.Set(TraceIDHeader, traceID.(string))
+		r.Header.Set(ParentSpanIDHeader, spanID.(string))
 	}
 
 	return d.Doer.Do(r)
 }
 
 // Info logs the trace ID when present then the values passed as argument.
 func (l *tracedLogger) Info(ctx context.Context, keyvals ...interface{}) {
-	traceID := ContextTraceID(ctx)
-	if traceID == "" {
-		l.LogAdapter.Info(ctx, keyvals...)
+	traceID := ctx.Value(TraceIDKey)
+	if traceID == nil {
+		l.Adapter.Info(ctx, keyvals...)
 		return
 	}
-	keyvals = append([]interface{}{"trace", traceID}, keyvals...)
-	l.LogAdapter.Info(ctx, keyvals)
+	keyvals = append([]interface{}{"trace", traceID.(string)}, keyvals...)
+	l.Adapter.Info(ctx, keyvals)
 }
 
 // Error logs the trace ID when present then the values passed as argument.
 func (l *tracedLogger) Error(ctx context.Context, keyvals ...interface{}) {
-	traceID := ContextTraceID(ctx)
-	if traceID == "" {
-		l.LogAdapter.Error(ctx, keyvals...)
+	traceID := ctx.Value(TraceIDKey)
+	if traceID == nil {
+		l.Adapter.Error(ctx, keyvals...)
 		return
 	}
-	keyvals = append([]interface{}{"trace", traceID}, keyvals...)
-	l.LogAdapter.Error(ctx, keyvals)
+	keyvals = append([]interface{}{"trace", traceID.(string)}, keyvals...)
+	l.Adapter.Error(ctx, keyvals)
 }
 
 // shortID produces a " unique" 6 bytes long string.

http/middleware/tracing/middleware_test.go

@@ -132,8 +132,6 @@ func TestMiddleware(t *testing.T) {
 
 	for k, c := range cases {
 		var (
-			ctxTraceID, ctxSpanID, ctxParentID string
-
 			m       = New(SamplingPercent(c.Rate), SpanIDFunc(newID), TraceIDFunc(newTraceID))
 			h       = new(testHandler)
 			headers = make(http.Header)
@@ -149,10 +147,19 @@ func TestMiddleware(t *testing.T) {
 
 		m(h).ServeHTTP(httptest.NewRecorder(), req)
 
-		ctx := h.Context
-		ctxTraceID = ContextTraceID(ctx)
-		ctxSpanID = ContextSpanID(ctx)
-		ctxParentID = ContextParentSpanID(ctx)
+		var ctxTraceID, ctxSpanID, ctxParentID string
+		{
+			ctx := h.Context
+			if traceID := ctx.Value(TraceIDKey); traceID != nil {
+				ctxTraceID = traceID.(string)
+			}
+			if spanID := ctx.Value(TraceSpanIDKey); spanID != nil {
+				ctxSpanID = spanID.(string)
+			}
+			if parentID := ctx.Value(TraceParentSpanIDKey); parentID != nil {
+				ctxParentID = parentID.(string)
+			}
+		}
 		if ctxTraceID != c.CtxTraceID {
 			t.Errorf("%s: invalid TraceID, expected %v - got %v", k, c.CtxTraceID, ctxTraceID)
 		}