fix context bug

Author: dbubel

examples/simple.go

@@ -37,20 +37,19 @@ func main() {
 	})
 
 	app := intake.New(apiLogger)
-	app.GlobalMiddleware(middleware.Logging(apiLogger, middleware.LogLevel{
+	eps := intake.Endpoints{
+		intake.NewEndpoint(http.MethodGet, "/test-get", testSimple),
+	}
+	eps.Use(middleware.Logging(apiLogger, middleware.LogLevel{
 		Log100s: true,
 		Log200s: true,
 		Log300s: true,
 		Log400s: true,
 		Log500s: true,
-	}), middleware.Recover)
-	eps := intake.Endpoints{
-		intake.NewEndpoint(http.MethodGet, "/test-get", testSimple),
-	}
+	}))
+	eps.Use(middleware.Timeout(time.Second * 2))
 	app.AddEndpoints(eps)
 
-
-
 	app.Run(&http.Server{
 		Addr:           ":8000",
 		Handler:        app.Router,

middleware/logging.go

@@ -1,12 +1,11 @@
 package middleware
 
 import (
-	"net/http"
-	"time"
-
 	"github.com/dbubel/intake"
 	"github.com/julienschmidt/httprouter"
 	"github.com/sirupsen/logrus"
+	"net/http"
+	"time"
 )
 
 type LogLevel struct {
@@ -21,6 +20,7 @@ func Logging(l *logrus.Logger, levels LogLevel) func(handler intake.Handler) int
 	return func(next intake.Handler) intake.Handler {
 		return func(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
 			t := time.Now()
+
 			defer func() {
 				var code int
 				if err := intake.FromContext(r, "response-code", &code); err != nil {
@@ -31,6 +31,7 @@ func Logging(l *logrus.Logger, levels LogLevel) func(handler intake.Handler) int
 				if err := intake.FromContext(r, "response-length", &responseLength); err != nil {
 					l.WithError(err).Error("error getting response length from context")
 				}
+
 				printLog := func() {
 					l.WithFields(logrus.Fields{
 						"method":           r.Method,
@@ -54,7 +55,6 @@ func Logging(l *logrus.Logger, levels LogLevel) func(handler intake.Handler) int
 				} else if code >= 500 && levels.Log500s {
 					printLog()
 				}
-
 			}()
 
 			next(w, r, params)

middleware/timeout.go

@@ -18,7 +18,8 @@ func Timeout(t time.Duration) func(handler intake.Handler) intake.Handler {
 			// cancel at the specified duration.
 			ctx, cancel := context.WithTimeout(r.Context(), t)
 			defer cancel()
-			next(w, r.WithContext(ctx), params)
+			*r = *r.WithContext(ctx)
+			next(w, r, params)
 		}
 	}
 }

requests.go

@@ -1,9 +1,7 @@
 package intake
 
 import (
-	"bytes"
 	"context"
-	"encoding/gob"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -30,22 +28,20 @@ func UnmarshalJSON(r io.Reader, v interface{}) error {
 }
 
 func AddToContext(r *http.Request, key string, v interface{}) error {
-	var b bytes.Buffer
-	e := gob.NewEncoder(&b)
-	if err := e.Encode(v); err != nil {
+	encoded, err := json.Marshal(v)
+	if err != nil {
 		return err
 	}
-	*r = *r.WithContext(context.WithValue(r.Context(), key, b))
+	*r = *r.WithContext(context.WithValue(r.Context(), key, encoded))
 	return nil
 }
 
 func FromContext(r *http.Request, key string, v interface{}) error {
-	data, ok := r.Context().Value(key).(bytes.Buffer)
+	data, ok := r.Context().Value(key).([]byte)
 	if !ok {
-		return fmt.Errorf("error casting from context for (%s)", key)
+		return fmt.Errorf("error casting to []byte for key %s", key)
 	}
-	d := gob.NewDecoder(&data)
-	if err := d.Decode(v); err != nil {
+	if err := json.Unmarshal(data, v); err != nil {
 		return err
 	}
 	return nil

responder.go

@@ -3,7 +3,6 @@ package intake
 import (
 	"encoding/json"
 	"encoding/xml"
-	"fmt"
 	"net/http"
 )
 
@@ -40,11 +39,12 @@ func RespondXML(w http.ResponseWriter, r *http.Request, code int, data interface
 func Respond(w http.ResponseWriter, r *http.Request, code int, data []byte) (int, error) {
 	err := AddToContext(r, "response-code", code)
 	if err != nil {
-		fmt.Println("adding", err.Error())
+		return 0, err
 	}
+
 	err = AddToContext(r, "response-length", len(data))
 	if err != nil {
-		fmt.Println("adding 1", err.Error())
+		return 0, err
 	}
 	contentType := http.DetectContentType(data)
 	w.Header().Set("Content-Type", contentType)