Using nothing but the standard library It is a common requirement to encounter the necessity of having various operations needed around incoming requests to your server. The most prevalent examples would be logging and tracing. Although there are various frameworks out there that provide this out of the box, I’d like to illustrate how simple it is to create this logic using nothing but the standard library. Building your own implementation gives you full flexibility and control over the behaviour, reducing the need for external dependencies. HTTP Ideally, I would prefer the API to look something like this, within the context of my naive example: In the above example, I used to create a wrapper for all my handlers, which augments both and with the logging and tracing that I’ve defined and passed as parameters to this function. chainMiddleware home about middleware In order for this to work, we need to define a middleware type. It can be defined as: Thereby, a will be defined as a function that returns a new handler which will perform some operations before (or after) calling the next handler that is provided as an argument. For the sake of brevity when illustrating these examples, we’ll be using instead of the classical . The behaviour is the same. middleware [http.HandlerFunc](https://golang.org/pkg/net/http#HandlerFunc) [http.Handler](https://golang.org/pkg/net/http#Handler) Using this pattern we define the dummy and middleware as such: withLogging withTracing Our middleware is purely illustrative and does nothing but log that an action has been taken. We could theoretically already use this implementation, without the need for , simply by defining each route as such: chainMiddleware This is good and it works but can quickly become tedious and verbose if we introduce more middleware. Thus, our chain function provides nice syntactic sugar for chaining multiple middleware into one. Let’s look at the implementation: By making use of the functional programming features of Go, we can use the above implementation to link a chain of middleware which call into one another in the provided order, returning a new wrapper for our handlers. We take each middleware function in the list in reverse order and pass its return value as an argument to the one before it, starting with the handler. In this way, the chain happens in the order that it is passed in. final Now, if we run the program and visit in the browser, we should expect to see something similar to the following output in the console, before the final handler is called: http://localhost:8080 main.go:34: Logged connection from [::1]:54962 main.go:41: Tracing request for / Simple as that! You can find the full running example . here
