Add log.F

Author: nhooyr

entry.go

@@ -85,7 +85,7 @@ func (ent entry) String() string {
 type entryConfig struct {
 	level  level
 	msg    string
-	fields []interface{}
+	fields []Field
 	skip   int
 }
 

examples_test.go

@@ -11,16 +11,16 @@ import (
 func Example_stderr() {
 	ctx := context.Background()
 	stderrlog.Info(ctx, "my message here",
-		"field_name", "something or the other",
-		"some_map", map[string]string{
+		slog.F("field_name", "something or the other"),
+		slog.F("some_map", map[string]string{
 			"nested_fields": "wowow",
-		},
-		"some slice", []interface{}{
+		}),
+		slog.F("some slice", []interface{}{
 			1,
 			"foof",
 			"bar",
 			true,
-		},
+		}),
 		slog.Component("test"),
 	)
 }
@@ -30,16 +30,20 @@ func Example_test() {
 	var t *testing.T
 
 	testlog.Info(t, "my message here",
-		"field_name", "something or the other",
-		"some_map", map[string]interface{}{
+		slog.F("field_name", "something or the other"),
+		slog.F("some_map", map[string]interface{}{
 			"nested_fields": "wowow",
-		},
-		"some slice", []interface{}{
+		}),
+		slog.F("some slice", []interface{}{
 			1,
 			"foof",
 			"bar",
 			true,
-		},
+		}),
 		slog.Component("test"),
+
+		slog.F("name", slog.ValueFunc(func() interface{} {
+			return "wow"
+		})),
 	)
 }

fields.go

@@ -3,7 +3,6 @@ package slog
 import (
 	"context"
 	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
 	"reflect"
 )
 
@@ -25,36 +24,13 @@ type parsedFields struct {
 	fields fieldMap
 }
 
-func parseFields(fields []interface{}) parsedFields {
+func parseFields(fields []Field) parsedFields {
 	var l parsedFields
+	l.fields = make(fieldMap, len(fields))
 
 	for i := 0; i < len(fields); i++ {
 		f := fields[i]
-		switch f := f.(type) {
-		case componentField:
-			l = l.appendComponent(string(f))
-			continue
-		case Field:
-			l = l.appendField(f.LogKey(), f)
-			continue
-		case string:
-			i++
-			if i < len(fields) {
-				v := fields[i]
-				l = l.appendField(f, v)
-				continue
-			}
-
-			// Missing value for key.
-			err := xerrors.Errorf("missing log value for key %v", f)
-			l = l.appendField("missing_value_error", err)
-		default:
-			// Unexpected key type.
-			err := xerrors.Errorf("unexpected log key of type %T: %#v", f, f)
-			l = l.appendField("bad_key_error", err)
-			// Skip the next value under the assumption that it is a value.
-			i++
-		}
+		l = l.appendField(f.LogKey(), f.LogValue())
 	}
 
 	return l
@@ -65,7 +41,7 @@ func (l parsedFields) appendField(k string, v interface{}) parsedFields {
 	return l
 }
 
-func (l parsedFields) withFields(f []interface{}) parsedFields {
+func (l parsedFields) withFields(f []Field) parsedFields {
 	return l.with(parseFields(f))
 }
 

logger.go

@@ -32,37 +32,37 @@ type logger struct {
 	skip int
 }
 
-func (sl logger) Debug(ctx context.Context, msg string, fields ...interface{}) {
+func (sl logger) Debug(ctx context.Context, msg string, fields ...Field) {
 	sl.log(ctx, levelDebug, msg, fields)
 }
 
-func (sl logger) Info(ctx context.Context, msg string, fields ...interface{}) {
+func (sl logger) Info(ctx context.Context, msg string, fields ...Field) {
 	sl.log(ctx, levelInfo, msg, fields)
 }
 
-func (sl logger) Warn(ctx context.Context, msg string, fields ...interface{}) {
+func (sl logger) Warn(ctx context.Context, msg string, fields ...Field) {
 	sl.log(ctx, levelWarn, msg, fields)
 }
 
-func (sl logger) Error(ctx context.Context, msg string, fields ...interface{}) {
+func (sl logger) Error(ctx context.Context, msg string, fields ...Field) {
 	sl.log(ctx, levelError, msg, fields)
 }
 
-func (sl logger) Critical(ctx context.Context, msg string, fields ...interface{}) {
+func (sl logger) Critical(ctx context.Context, msg string, fields ...Field) {
 	sl.log(ctx, levelCritical, msg, fields)
 }
 
-func (sl logger) Fatal(ctx context.Context, msg string, fields ...interface{}) {
+func (sl logger) Fatal(ctx context.Context, msg string, fields ...Field) {
 	sl.log(ctx, levelFatal, msg, fields)
 	os.Exit(1)
 }
 
-func (sl logger) With(fields ...interface{}) Logger {
+func (sl logger) With(fields ...Field) Logger {
 	sl.l = sl.l.withFields(fields)
 	return sl
 }
 
-func (sl logger) log(ctx context.Context, sev level, msg string, fields []interface{}) {
+func (sl logger) log(ctx context.Context, sev level, msg string, fields []Field) {
 	ent := sl.l.entry(ctx, entryConfig{
 		level:  sev,
 		msg:    msg,

slog.go

@@ -6,23 +6,23 @@ import (
 
 type Logger interface {
 	// Debug means a potentially noisy log.
-	Debug(ctx context.Context, msg string, fields ...interface{})
+	Debug(ctx context.Context, msg string, fields ...Field)
 	// Info means an informational log.
-	Info(ctx context.Context, msg string, fields ...interface{})
+	Info(ctx context.Context, msg string, fields ...Field)
 	// Warn means something may be going wrong.
-	Warn(ctx context.Context, msg string, fields ...interface{})
+	Warn(ctx context.Context, msg string, fields ...Field)
 	// Error means the an error occured but does not require immediate attention.
-	Error(ctx context.Context, msg string, fields ...interface{})
+	Error(ctx context.Context, msg string, fields ...Field)
 	// Critical means an error occured and requires immediate attention.
-	Critical(ctx context.Context, msg string, fields ...interface{})
+	Critical(ctx context.Context, msg string, fields ...Field)
 	// Fatal is the same as critical but calls os.Exit(1) afterwards.
-	Fatal(ctx context.Context, msg string, fields ...interface{})
+	Fatal(ctx context.Context, msg string, fields ...Field)
 
 	// With returns a logger that will merge the given fields with all fields logged.
 	// Fields logged with one of the above methods or from the context will always take priority.
 	// Use the global with function when the fields being stored belong in the context and this
 	// when they do not.
-	With(fields ...interface{}) Logger
+	With(fields ...Field) Logger
 }
 
 // field represents a log field.
@@ -48,33 +48,44 @@ func (fn ValueFunc) LogValue() interface{} {
 
 type componentField string
 
+func (c componentField) LogKey() string        { panic("never called") }
+func (c componentField) LogValue() interface{} { panic("never called") }
+
 // Component represents the component a log is being logged for.
 // If there is already a component set, it will be joined by ".".
 // E.g. if the component is currently "my_component" and then later
 // the component "my_pkg" is set, then the final component will be
 // "my_component.my_pkg".
-func Component(name string) interface{} {
+func Component(name string) Field {
 	return componentField(name)
 }
 
-type errorField struct {
+type unparsedField struct {
 	name string
-	err  error
+	v    interface{}
+}
+
+func (f unparsedField) LogKey() string {
+	return f.name
 }
 
-func (e errorField) LogKey() string {
-	return e.name
+func (f unparsedField) LogValue() interface{} {
+	return f.v
 }
 
-func (e errorField) LogValue() interface{} {
-	return e.err
+// F is used to log arbitrary fields with the logger.
+func F(name string, v interface{}) Field {
+	return unparsedField{
+		name: name,
+		v:    v,
+	}
 }
 
 // Error is the standard key used for logging a Go error value.
 func Error(err error) Field {
-	return errorField{
+	return unparsedField{
 		name: "error",
-		err:  err,
+		v:    err,
 	}
 }
 
@@ -92,7 +103,7 @@ func fromContext(ctx context.Context) parsedFields {
 // With returns a context that contains the given fields.
 // Any logs written with the provided context will contain
 // the given fields.
-func With(ctx context.Context, fields ...interface{}) context.Context {
+func With(ctx context.Context, fields ...Field) context.Context {
 	l := fromContext(ctx)
 	l = l.withFields(fields)
 	return withContext(ctx, l)

stderrlog/stderrlog.go

@@ -19,31 +19,31 @@ func init() {
 }
 
 // Debug logs the given msg and fields on the debug level to stderr.
-func Debug(ctx context.Context, msg string, fields ...interface{}) {
+func Debug(ctx context.Context, msg string, fields ...slog.Field) {
 	stderrLogger.Debug(skipctx.With(ctx, 1), msg, fields...)
 }
 
 // Info logs the given msg and fields on the info level to stderr.
-func Info(ctx context.Context, msg string, fields ...interface{}) {
+func Info(ctx context.Context, msg string, fields ...slog.Field) {
 	stderrLogger.Info(skipctx.With(ctx, 1), msg, fields...)
 }
 
 // Warn logs the given msg and fields on the warn level to stderr.
-func Warn(ctx context.Context, msg string, fields ...interface{}) {
+func Warn(ctx context.Context, msg string, fields ...slog.Field) {
 	stderrLogger.Warn(skipctx.With(ctx, 1), msg, fields...)
 }
 
 // Error logs the given msg and fields on the error level to stderr.
-func Error(ctx context.Context, msg string, fields ...interface{}) {
+func Error(ctx context.Context, msg string, fields ...slog.Field) {
 	stderrLogger.Error(skipctx.With(ctx, 1), msg, fields...)
 }
 
 // Critical logs the given msg and fields on the critical level to stderr.
-func Critical(ctx context.Context, msg string, fields ...interface{}) {
+func Critical(ctx context.Context, msg string, fields ...slog.Field) {
 	stderrLogger.Critical(skipctx.With(ctx, 1), msg, fields...)
 }
 
 // Fatal logs the given msg and fields on the fatal level to stderr.
-func Fatal(ctx context.Context, msg string, fields ...interface{}) {
+func Fatal(ctx context.Context, msg string, fields ...slog.Field) {
 	stderrLogger.Fatal(skipctx.With(ctx, 1), msg, fields...)
 }

tee.go

@@ -18,31 +18,31 @@ type multiLogger struct {
 	loggers []Logger
 }
 
-func (l multiLogger) Debug(ctx context.Context, msg string, fields ...interface{}) {
+func (l multiLogger) Debug(ctx context.Context, msg string, fields ...Field) {
 	l.log(ctx, levelDebug, msg, fields)
 }
 
-func (l multiLogger) Info(ctx context.Context, msg string, fields ...interface{}) {
+func (l multiLogger) Info(ctx context.Context, msg string, fields ...Field) {
 	l.log(ctx, levelInfo, msg, fields)
 }
 
-func (l multiLogger) Warn(ctx context.Context, msg string, fields ...interface{}) {
+func (l multiLogger) Warn(ctx context.Context, msg string, fields ...Field) {
 	l.log(ctx, levelWarn, msg, fields)
 }
 
-func (l multiLogger) Error(ctx context.Context, msg string, fields ...interface{}) {
+func (l multiLogger) Error(ctx context.Context, msg string, fields ...Field) {
 	l.log(ctx, levelError, msg, fields)
 }
 
-func (l multiLogger) Critical(ctx context.Context, msg string, fields ...interface{}) {
+func (l multiLogger) Critical(ctx context.Context, msg string, fields ...Field) {
 	l.log(ctx, levelCritical, msg, fields)
 }
 
-func (l multiLogger) Fatal(ctx context.Context, msg string, fields ...interface{}) {
+func (l multiLogger) Fatal(ctx context.Context, msg string, fields ...Field) {
 	l.log(ctx, levelDebug, msg, fields)
 }
 
-func (l multiLogger) log(ctx context.Context, level level, msg string, fields []interface{}) {
+func (l multiLogger) log(ctx context.Context, level level, msg string, fields []Field) {
 	ctx = skipctx.With(ctx, 2)
 	for _, l := range l.loggers {
 		switch level {
@@ -64,11 +64,11 @@ func (l multiLogger) log(ctx context.Context, level level, msg string, fields []
 	}
 }
 
-func (l multiLogger) With(fields ...interface{}) Logger {
+func (l multiLogger) With(fields ...Field) Logger {
 	loggers2 := make([]Logger, len(l.loggers))
 
 	for i, l := range l.loggers {
-		loggers2[i] = l.With(fields)
+		loggers2[i] = l.With(fields...)
 	}
 
 	return multiLogger{

test.go

@@ -27,42 +27,42 @@ type testLogger struct {
 	p      parsedFields
 }
 
-func (tl testLogger) Debug(ctx context.Context, msg string, fields ...interface{}) {
+func (tl testLogger) Debug(ctx context.Context, msg string, fields ...Field) {
 	tl.tb.Helper()
 	tl.log(ctx, levelDebug, msg, fields)
 }
 
-func (tl testLogger) Info(ctx context.Context, msg string, fields ...interface{}) {
+func (tl testLogger) Info(ctx context.Context, msg string, fields ...Field) {
 	tl.tb.Helper()
 	tl.log(ctx, levelInfo, msg, fields)
 }
 
-func (tl testLogger) Warn(ctx context.Context, msg string, fields ...interface{}) {
+func (tl testLogger) Warn(ctx context.Context, msg string, fields ...Field) {
 	tl.tb.Helper()
 	tl.log(ctx, levelWarn, msg, fields)
 }
 
-func (tl testLogger) Error(ctx context.Context, msg string, fields ...interface{}) {
+func (tl testLogger) Error(ctx context.Context, msg string, fields ...Field) {
 	tl.tb.Helper()
 	tl.log(ctx, levelError, msg, fields)
 }
 
-func (tl testLogger) Critical(ctx context.Context, msg string, fields ...interface{}) {
+func (tl testLogger) Critical(ctx context.Context, msg string, fields ...Field) {
 	tl.tb.Helper()
 	tl.log(ctx, levelCritical, msg, fields)
 }
 
-func (tl testLogger) Fatal(ctx context.Context, msg string, fields ...interface{}) {
+func (tl testLogger) Fatal(ctx context.Context, msg string, fields ...Field) {
 	tl.tb.Helper()
 	tl.log(ctx, levelFatal, msg, fields)
 }
 
-func (tl testLogger) With(fields ...interface{}) Logger {
+func (tl testLogger) With(fields ...Field) Logger {
 	tl.p = tl.p.withFields(fields)
 	return tl
 }
 
-func (tl testLogger) log(ctx context.Context, level level, msg string, fields []interface{}) {
+func (tl testLogger) log(ctx context.Context, level level, msg string, fields []Field) {
 	tl.tb.Helper()
 
 	ent := tl.p.entry(ctx, entryConfig{