Merge v1.2.1-master

Signed-off-by: Emile Vauge <emile@vauge.com>

vendor/github.com/codegangsta/negroni/logger.go

@@ -1,29 +1,80 @@
 package negroni
 
 import (
+	"bytes"
+
 	"log"
 	"net/http"
 	"os"
+	"text/template"
 	"time"
 )
 
+// LoggerEntry is the structure
+// passed to the template.
+type LoggerEntry struct {
+	StartTime string
+	Status    int
+	Duration  time.Duration
+	Hostname  string
+	Method    string
+	Path      string
+}
+
+// LoggerDefaultFormat is the format
+// logged used by the default Logger instance.
+var LoggerDefaultFormat = "{{.StartTime}} | {{.Status}} | \t {{.Duration}} | {{.Hostname}} | {{.Method}} {{.Path}} \n"
+
+// LoggerDefaultDateFormat is the
+// format used for date by the
+// default Logger instance.
+var LoggerDefaultDateFormat = time.RFC3339
+
+// ALogger interface
+type ALogger interface {
+	Println(v ...interface{})
+	Printf(format string, v ...interface{})
+}
+
 // Logger is a middleware handler that logs the request as it goes in and the response as it goes out.
 type Logger struct {
-	// Logger inherits from log.Logger used to log messages with the Logger middleware
-	*log.Logger
+	// ALogger implements just enough log.Logger interface to be compatible with other implementations
+	ALogger
+	dateFormat string
+	template   *template.Template
 }
 
 // NewLogger returns a new Logger instance
 func NewLogger() *Logger {
-	return &Logger{log.New(os.Stdout, "[negroni] ", 0)}
+	logger := &Logger{ALogger: log.New(os.Stdout, "[negroni] ", 0), dateFormat: LoggerDefaultDateFormat}
+	logger.SetFormat(LoggerDefaultFormat)
+	return logger
+}
+
+func (l *Logger) SetFormat(format string) {
+	l.template = template.Must(template.New("negroni_parser").Parse(format))
+}
+
+func (l *Logger) SetDateFormat(format string) {
+	l.dateFormat = format
 }
 
 func (l *Logger) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
 	start := time.Now()
-	l.Printf("Started %s %s", r.Method, r.URL.Path)
 
 	next(rw, r)
 
 	res := rw.(ResponseWriter)
-	l.Printf("Completed %v %s in %v", res.Status(), http.StatusText(res.Status()), time.Since(start))
+	log := LoggerEntry{
+		StartTime: start.Format(l.dateFormat),
+		Status:    res.Status(),
+		Duration:  time.Since(start),
+		Hostname:  r.Host,
+		Method:    r.Method,
+		Path:      r.URL.Path,
+	}
+
+	buff := &bytes.Buffer{}
+	l.template.Execute(buff, log)
+	l.Printf(buff.String())
 }

vendor/github.com/codegangsta/negroni/negroni.go

@@ -59,6 +59,14 @@ func New(handlers ...Handler) *Negroni {
 	}
 }
 
+// With returns a new Negroni instance that is a combination of the negroni
+// receiver's handlers and the provided handlers.
+func (n *Negroni) With(handlers ...Handler) *Negroni {
+	return New(
+		append(n.handlers, handlers...)...,
+	)
+}
+
 // Classic returns a new Negroni instance with the default middleware already
 // in the stack.
 //

vendor/github.com/codegangsta/negroni/recovery.go

@@ -11,7 +11,7 @@ import (
 
 // Recovery is a Negroni middleware that recovers from any panics and writes a 500 if there was one.
 type Recovery struct {
-	Logger           *log.Logger
+	Logger           ALogger
 	PrintStack       bool
 	ErrorHandlerFunc func(interface{})
 	StackAll         bool

vendor/github.com/codegangsta/negroni/response_writer.go

@@ -29,9 +29,15 @@ type beforeFunc func(ResponseWriter)
 
 // NewResponseWriter creates a ResponseWriter that wraps an http.ResponseWriter
 func NewResponseWriter(rw http.ResponseWriter) ResponseWriter {
-	return &responseWriter{
+	nrw := &responseWriter{
 		ResponseWriter: rw,
 	}
+
+	if _, ok := rw.(http.CloseNotifier); ok {
+		return &responseWriterCloseNotifer{nrw}
+	}
+
+	return nrw
 }
 
 type responseWriter struct {
@@ -81,10 +87,6 @@ func (rw *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	return hijacker.Hijack()
 }
 
-func (rw *responseWriter) CloseNotify() <-chan bool {
-	return rw.ResponseWriter.(http.CloseNotifier).CloseNotify()
-}
-
 func (rw *responseWriter) callBefore() {
 	for i := len(rw.beforeFuncs) - 1; i >= 0; i-- {
 		rw.beforeFuncs[i](rw)
@@ -94,6 +96,18 @@ func (rw *responseWriter) callBefore() {
 func (rw *responseWriter) Flush() {
 	flusher, ok := rw.ResponseWriter.(http.Flusher)
 	if ok {
+		if !rw.Written() {
+			// The status will be StatusOK if WriteHeader has not been called yet
+			rw.WriteHeader(http.StatusOK)
+		}
 		flusher.Flush()
 	}
 }
+
+type responseWriterCloseNotifer struct {
+	*responseWriter
+}
+
+func (rw *responseWriterCloseNotifer) CloseNotify() <-chan bool {
+	return rw.ResponseWriter.(http.CloseNotifier).CloseNotify()
+}