log/alt_experimental_level: concept demonstration

log/alt_experimental_level/benchmark_test.go

@@ -0,0 +1,59 @@
+package level_test
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/log/alt_experimental_level"
+)
+
+func BenchmarkNopBaseline(b *testing.B) {
+	benchmarkRunner(b, log.NewNopLogger())
+}
+
+func BenchmarkNopDisallowedLevel(b *testing.B) {
+	level.AllowInfoAndAbove()
+	benchmarkRunner(b, log.NewNopLogger())
+}
+
+func BenchmarkNopAllowedLevel(b *testing.B) {
+	level.AllowAll()
+	benchmarkRunner(b, log.NewNopLogger())
+}
+
+func BenchmarkJSONBaseline(b *testing.B) {
+	benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard))
+}
+
+func BenchmarkJSONDisallowedLevel(b *testing.B) {
+	level.AllowInfoAndAbove()
+	benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard))
+}
+
+func BenchmarkJSONAllowedLevel(b *testing.B) {
+	level.AllowAll()
+	benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard))
+}
+
+func BenchmarkLogfmtBaseline(b *testing.B) {
+	benchmarkRunner(b, log.NewLogfmtLogger(ioutil.Discard))
+}
+
+func BenchmarkLogfmtDisallowedLevel(b *testing.B) {
+	level.AllowInfoAndAbove()
+	benchmarkRunner(b, log.NewLogfmtLogger(ioutil.Discard))
+}
+
+func BenchmarkLogfmtAllowedLevel(b *testing.B) {
+	level.AllowAll()
+	benchmarkRunner(b, log.NewLogfmtLogger(ioutil.Discard))
+}
+
+func benchmarkRunner(b *testing.B, logger log.Logger) {
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		level.Debug(logger).Log("foo", "bar")
+	}
+}

log/alt_experimental_level/global.go

@@ -0,0 +1,73 @@
+package level
+
+import (
+	"github.com/go-kit/kit/log"
+)
+
+var (
+	global = AllowingNone()
+	/*
+	   Alternately:
+	   global atomic.Value
+	*/
+)
+
+/* Alternately:
+func init() {
+	global.Store(errorOnly{})
+}
+*/
+
+func resetGlobal(proposed Leveler) {
+	global = proposed
+	/* Alternately:
+	global.Store(proposed)
+	*/
+}
+
+func AllowAll() {
+	AllowDebugAndAbove()
+}
+
+func AllowDebugAndAbove() {
+	resetGlobal(AllowingDebugAndAbove())
+}
+
+func AllowInfoAndAbove() {
+	resetGlobal(AllowingInfoAndAbove())
+}
+
+func AllowWarnAndAbove() {
+	resetGlobal(AllowingWarnAndAbove())
+}
+
+func AllowErrorOnly() {
+	resetGlobal(AllowingErrorOnly())
+}
+
+func AllowNone() {
+	resetGlobal(AllowingNone())
+}
+
+func getGlobal() Leveler {
+	return global
+	/* Alternately:
+	return global.Load().(Leveler)
+	*/
+}
+
+func Debug(logger log.Logger) log.Logger {
+	return getGlobal().Debug(logger)
+}
+
+func Info(logger log.Logger) log.Logger {
+	return getGlobal().Info(logger)
+}
+
+func Warn(logger log.Logger) log.Logger {
+	return getGlobal().Warn(logger)
+}
+
+func Error(logger log.Logger) log.Logger {
+	return getGlobal().Error(logger)
+}

log/alt_experimental_level/level.go

@@ -0,0 +1,96 @@
+package level
+
+import (
+	"github.com/go-kit/kit/log"
+)
+
+var (
+	// Alternately, we could use a similarly inert logger that does nothing but
+	// return a given error value.
+	nop = log.NewNopLogger()
+)
+
+type Leveler interface {
+	Debug(logger log.Logger) log.Logger
+	Info(logger log.Logger) log.Logger
+	Warn(logger log.Logger) log.Logger
+	Error(logger log.Logger) log.Logger
+}
+
+func withLevel(level string, logger log.Logger) log.Logger {
+	return log.NewContext(logger).With("level", level)
+}
+
+type debugAndAbove struct{}
+
+func (debugAndAbove) Debug(logger log.Logger) log.Logger {
+	return withLevel("debug", logger)
+}
+
+func (debugAndAbove) Info(logger log.Logger) log.Logger {
+	return withLevel("info", logger)
+}
+
+func (debugAndAbove) Warn(logger log.Logger) log.Logger {
+	return withLevel("warn", logger)
+}
+
+func (debugAndAbove) Error(logger log.Logger) log.Logger {
+	return withLevel("error", logger)
+}
+
+type infoAndAbove struct {
+	debugAndAbove
+}
+
+func (infoAndAbove) Debug(logger log.Logger) log.Logger {
+	return nop
+}
+
+type warnAndAbove struct {
+	infoAndAbove
+}
+
+func (warnAndAbove) Info(logger log.Logger) log.Logger {
+	return nop
+}
+
+type errorOnly struct {
+	warnAndAbove
+}
+
+func (errorOnly) Warn(logger log.Logger) log.Logger {
+	return nop
+}
+
+type none struct {
+	errorOnly
+}
+
+func (none) Error(logger log.Logger) log.Logger {
+	return nop
+}
+
+func AllowingAll() Leveler {
+	return AllowingDebugAndAbove()
+}
+
+func AllowingDebugAndAbove() Leveler {
+	return debugAndAbove{}
+}
+
+func AllowingInfoAndAbove() Leveler {
+	return infoAndAbove{}
+}
+
+func AllowingWarnAndAbove() Leveler {
+	return warnAndAbove{}
+}
+
+func AllowingErrorOnly() Leveler {
+	return errorOnly{}
+}
+
+func AllowingNone() Leveler {
+	return none{}
+}