go-chi · Nov 30, 2016 · Jan 7, 2017 · Jan 8, 2017 · Jan 15, 2017 · Jan 15, 2017
diff --git a/.travis.yml b/.travis.yml
@@ -1,7 +1,8 @@
 language: go
 
 go:
-  - 1.7.4
+  - 1.7.x
+  - 1.8.x
   - tip
 
 install:

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,14 @@
 # Changelog
 
+## v2.1.0 (2017-03-30)
+
+- Minor improvements and update to the chi core library
+- Introduced a brand new `chi/render` sub-package to complete the story of building
+APIs to offer a pattern for managing well-defined request / response payloads. Please
+check out the updated `_examples/rest` example for how it works.
+- Added `MethodNotAllowed(h http.HandlerFunc)` to chi.Router interface
+
+
 ## v2.0.0 (2017-01-06)
 
 - After many months of v2 being in an RC state with many companies and users running it in

diff --git a/README.md b/README.md
@@ -1,5 +1,5 @@
-<img alt="chi" src="https://cdn.rawgit.com/pressly/chi/master/_examples/chi.svg" width="220" />
-===
+# <img alt="chi" src="https://cdn.rawgit.com/pressly/chi/master/_examples/chi.svg" width="220" />
+
 
 [![GoDoc Widget]][GoDoc] [![Travis Widget]][Travis]
 
@@ -17,6 +17,8 @@ handlers (stdlib-only), developer productivity, and deconstructing a large syste
 parts. The core router `github.com/pressly/chi` is quite small (less than 1000 LOC), but we've also
 included some useful/optional subpackages: `middleware`, `render` and `docgen`. We hope you enjoy it too!
 
+## Install
+
 `go get -u github.com/pressly/chi`
 
 
@@ -230,7 +232,9 @@ type Routes interface {
 ```
 
 Each routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern
-supports named params (ie. `/users/:userID`) and wildcards (ie. `/admin/*`).
+supports named params (ie. `/users/:userID`) and wildcards (ie. `/admin/*`). URL parameters
+can be fetched at runtime by calling `chi.URLParam(r, "userID")` for named parameters
+and `chi.URLParam(r, "*")` for a wildcard parameter.
 
 
 ### Middleware handlers
@@ -295,23 +299,23 @@ chi comes equipped with an optional `middleware` package, providing a suite of s
 `net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible
 with `net/http` can be used with chi's mux.
 
---------------------------------------------------------------------------------------------------
-| Middleware   | Description                                                                     |
-|:-------------|:---------------------------------------------------------------------------------
-| RequestID    | Injects a request ID into the context of each request.                          |
-| RealIP       | Sets a http.Request's RemoteAddr to either X-Forwarded-For or X-Real-IP.        |
-| Logger       | Logs the start and end of each request with the elapsed processing time.        |
-| Recoverer    | Gracefully absorb panics and prints the stack trace.                            |
-| NoCache      | Sets response headers to prevent clients from caching.                          |
-| CloseNotify  | Signals to the request context when a client has closed their connection.       |
-| Timeout      | Signals to the request context when the timeout deadline is reached.            |
-| Throttle     | Puts a ceiling on the number of concurrent requests.                            |
-| Compress     | Gzip compression for clients that accept compressed responses.                  |
-| Profiler     | Easily attach net/http/pprof to your routers.                                   |
-| Slashes      | Strip and redirect slashes on routing paths.                                    |
-| WithValue    | Short-hand middleware to set a key/value on the request context.                |
-| Heartbeat    | Monitoring endpoint to check the servers pulse.                                 |
---------------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------------------------
+| Middleware           | Description                                                                     |
+|:---------------------|:---------------------------------------------------------------------------------
+| RequestID            | Injects a request ID into the context of each request.                          |
+| RealIP               | Sets a http.Request's RemoteAddr to either X-Forwarded-For or X-Real-IP.        |
+| Logger               | Logs the start and end of each request with the elapsed processing time.        |
+| Recoverer            | Gracefully absorb panics and prints the stack trace.                            |
+| NoCache              | Sets response headers to prevent clients from caching.                          |
+| Timeout              | Signals to the request context when the timeout deadline is reached.            |
+| Throttle             | Puts a ceiling on the number of concurrent requests.                            |
+| Compress             | Gzip compression for clients that accept compressed responses.                  |
+| Profiler             | Easily attach net/http/pprof to your routers.                                   |
+| StripSlashes         | Strip slashes on routing paths.                                                 |
+| RedirectSlashes      | Redirect slashes on routing paths.                                              |
+| WithValue            | Short-hand middleware to set a key/value on the request context.                |
+| Heartbeat            | Monitoring endpoint to check the servers pulse.                                 |
+----------------------------------------------------------------------------------------------------------
 
 Other cool net/http middlewares:
 
@@ -339,31 +343,31 @@ and..
 
 The benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark
 
-Comparison with other routers (as of Aug 1/16): https://gist.github.com/pkieltyka/76a59d33492dd2732e691ad8c0b274a4
+Comparison with other routers (as of Jan 7/17): https://gist.github.com/pkieltyka/d0814d5396c996cb3ff8076399583d1f
 
 ```shell
-BenchmarkChi_Param        	 5000000	       251 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_Param5       	 5000000	       393 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_Param20      	 1000000	      1012 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_ParamWrite   	 5000000	       301 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_GithubStatic 	 5000000	       287 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_GithubParam  	 3000000	       442 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_GithubAll    	   20000	     90855 ns/op	   48723 B/op	     203 allocs/op
-BenchmarkChi_GPlusStatic  	 5000000	       250 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_GPlusParam   	 5000000	       280 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_GPlus2Params 	 5000000	       337 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_GPlusAll     	  300000	      4128 ns/op	    3120 B/op	      13 allocs/op
-BenchmarkChi_ParseStatic  	 5000000	       250 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_ParseParam   	 5000000	       275 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_Parse2Params 	 5000000	       305 ns/op	     240 B/op	       1 allocs/op
-BenchmarkChi_ParseAll     	  200000	      7671 ns/op	    6240 B/op	      26 allocs/op
-BenchmarkChi_StaticAll    	   30000	     55497 ns/op	   37682 B/op	     157 allocs/op
+BenchmarkChi_Param        	 5000000	       398 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Param5       	 3000000	       556 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Param20      	 1000000	      1184 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParamWrite   	 3000000	       443 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubStatic 	 3000000	       427 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubParam  	 3000000	       565 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GithubAll    	   10000	    122143 ns/op	   61716 B/op	     406 allocs/op
+BenchmarkChi_GPlusStatic  	 5000000	       383 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlusParam   	 3000000	       431 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlus2Params 	 3000000	       500 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_GPlusAll     	  200000	      6410 ns/op	    3952 B/op	      26 allocs/op
+BenchmarkChi_ParseStatic  	 5000000	       384 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParseParam   	 3000000	       415 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_Parse2Params 	 3000000	       450 ns/op	     304 B/op	       2 allocs/op
+BenchmarkChi_ParseAll     	  100000	     12124 ns/op	    7904 B/op	      52 allocs/op
+BenchmarkChi_StaticAll    	   20000	     78501 ns/op	   47731 B/op	     314 allocs/op
 ```
 
 NOTE: the allocs in the benchmark above are from the calls to http.Request's
 `WithContext(context.Context)` method that clones the http.Request, sets the `Context()`
 on the duplicated (alloc'd) request and returns it the new request object. This is just
-how setting context on a request in Go 1.7 works. 
+how setting context on a request in Go 1.7+ works.
 
 
 ## Credits
@@ -390,7 +394,7 @@ and even [graphql](https://github.com/graphql-go/graphql). They're all pretty co
 own unique approaches and benefits. Specifically, I'd look at gRPC since it makes client-server
 communication feel like a single program on a single computer, no need to hand-write a client library
 and the request/response payloads are typed contracts. NATS is pretty amazing too as a super
-fast and lightweight pub-sub transport that can speak protobufs, with nice service discovery - 
+fast and lightweight pub-sub transport that can speak protobufs, with nice service discovery -
 an excellent combination with gRPC.
 
 

diff --git a/_examples/logging/main.go b/_examples/logging/main.go
@@ -6,6 +6,10 @@
 // logger using the amazing Sirupsen/logrus package as the logging
 // backend.
 //
+// Also: check out https://github.com/pressly/lg for an improved context
+// logger with support for HTTP request logging, based on the example
+// below.
+//
 package main
 
 import (
@@ -20,9 +24,14 @@ import (
 
 func main() {
 
-	// Setup the logger
+	// Setup the logger backend using Sirupsen/logrus and configure
+	// it to use a custom JSONFormatter. See the logrus docs for how to
+	// configure the backend at github.com/Sirupsen/logrus
 	logger := logrus.New()
-	logger.Formatter = &logrus.JSONFormatter{} // optional / configurable, see docs
+	logger.Formatter = &logrus.JSONFormatter{
+		// disable, as we set our own
+		DisableTimestamp: true,
+	}
 
 	// Routes
 	r := chi.NewRouter()
@@ -46,19 +55,19 @@ func main() {
 
 // StructuredLogger is a simple, but powerful implementation of a custom structured
 // logger backed on logrus. I encourage users to copy it, adapt it and make it their
-// own. It's well suited to live in its own package, and likely soon I will update
-// github.com/goware/lg to use this implementation.
+// own. Also take a look at https://github.com/pressly/lg for a dedicated pkg based
+// on this work, designed for context-based http routers.
 
 func NewStructuredLogger(logger *logrus.Logger) func(next http.Handler) http.Handler {
 	return middleware.RequestLogger(&StructuredLogger{logger})
 }
 
 type StructuredLogger struct {
-	logger *logrus.Logger
+	Logger *logrus.Logger
 }
 
 func (l *StructuredLogger) NewLogEntry(r *http.Request) middleware.LogEntry {
-	entry := &StructuredLoggerEntry{logger: logrus.NewEntry(l.logger)}
+	entry := &StructuredLoggerEntry{Logger: logrus.NewEntry(l.Logger)}
 	logFields := logrus.Fields{}
 
 	logFields["ts"] = time.Now().UTC().Format(time.RFC1123)
@@ -80,33 +89,28 @@ func (l *StructuredLogger) NewLogEntry(r *http.Request) middleware.LogEntry {
 
 	logFields["uri"] = fmt.Sprintf("%s://%s%s", scheme, r.Host, r.RequestURI)
 
-	entry.logger = entry.logger.WithFields(logFields)
+	entry.Logger = entry.Logger.WithFields(logFields)
 
-	entry.logger.Infoln("request started")
+	entry.Logger.Infoln("request started")
 
 	return entry
 }
 
 type StructuredLoggerEntry struct {
-	logger logrus.FieldLogger
+	Logger logrus.FieldLogger
 }
 
 func (l *StructuredLoggerEntry) Write(status, bytes int, elapsed time.Duration) {
-	l.logger = l.logger.WithFields(logrus.Fields{
+	l.Logger = l.Logger.WithFields(logrus.Fields{
 		"resp_status": status, "resp_bytes_length": bytes,
 		"resp_elasped_ms": float64(elapsed.Nanoseconds()) / 1000000.0,
 	})
 
-	if status == middleware.StatusClientClosedRequest {
-		l.logger.Infoln("[disconnected]")
-		return
-	}
-
-	l.logger.Infoln("request complete")
+	l.Logger.Infoln("request complete")
 }
 
 func (l *StructuredLoggerEntry) Panic(v interface{}, stack []byte) {
-	l.logger = l.logger.WithFields(logrus.Fields{
+	l.Logger = l.Logger.WithFields(logrus.Fields{
 		"stack": string(stack),
 		"panic": fmt.Sprintf("%+v", v),
 	})
@@ -121,17 +125,17 @@ func (l *StructuredLoggerEntry) Panic(v interface{}, stack []byte) {
 
 func GetLogEntry(r *http.Request) logrus.FieldLogger {
 	entry := middleware.GetLogEntry(r).(*StructuredLoggerEntry)
-	return entry.logger
+	return entry.Logger
 }
 
 func LogEntrySetField(r *http.Request, key string, value interface{}) {
-	entry := middleware.GetLogEntry(r).(*StructuredLoggerEntry)
-	entry.logger = entry.logger.WithField(key, value)
-	middleware.WithLogEntry(r, entry)
+	if entry, ok := r.Context().Value(middleware.LogEntryCtxKey).(*StructuredLoggerEntry); ok {
+		entry.Logger = entry.Logger.WithField(key, value)
+	}
 }
 
 func LogEntrySetFields(r *http.Request, fields map[string]interface{}) {
-	entry := middleware.GetLogEntry(r).(*StructuredLoggerEntry)
-	entry.logger = entry.logger.WithFields(fields)
-	middleware.WithLogEntry(r, entry)
+	if entry, ok := r.Context().Value(middleware.LogEntryCtxKey).(*StructuredLoggerEntry); ok {
+		entry.Logger = entry.Logger.WithFields(fields)
+	}
 }