In my previous post I suggested that the best way to break the compile time coupling between the logger and the loggee was passing in a logger interface when constructing each major type in your program. The suggestion has been floated several times that logging is context specific, so maybe a logger can be passed around via a
context.Context. I think this suggestion is flawed (as are most uses of
context.Value, but that’s another story). This post explains why.
context.Value() is goroutine thread local storage
context.Context to pass a logger into a function is a poor design pattern. In effect
context.Context is being used as a conduit to arbitrarily extend the API of any method that takes a
context.Context value. It’s like Python’s
**kwargs, or whatever the name is for that Ruby pattern of always passing a hash. Using
context.Context in this way avoids an API break by smuggling data in the unstructured bag of values attached to the context. It’s thread local storage in a cheap suit.
It’s not just that values are boxed into an
context.WithValue that I object to. The far more serious concern is there is no schema to this data, so there is no way for a method that takes a context to ensure that it contains the specific key required to complete the operation.
nil if the key is not found, which means any code doing the naïve
log := ctx.Value("logger").(log.Logger) log.Warn("something you'll ignore later")
will blow up if the
"logger" key is not present.
Sure, you can check that the assertion succeeded, but I feel pretty confident that if this pattern were to become popular then people would eschew the two arg form of type assertion and just expect that the key always returned a valid logger. This would be especially true as logging in error paths is rarely tested, so you’ll hit this when you need it the most.
In my opinion passing loggers inside
context.Context would be the worst solution to the problem of decoupling loggers from implementations. We’d have gone from an explicit compile time dependency to an implicit run time dependency, one that could not be enforced by the compiler.
To quote @freeformz
Loggers should be injected into dependencies. Full stop.
It’s verbose, but it’s the only way to achieve decoupled design.