Finish rewrite

- Finished io.Writer logger and test logger
- Added stderrlog and testlog packages.

Author: nhooyr

console.go

@@ -64,7 +64,7 @@ func (y *consoleMarshaller) marshal(v fieldValue) {
 				y.line()
 			}
 
-			y.s(quoteMapKey(f.name) + ":")
+			y.s(quote(f.name) + ":")
 
 			y.marshalSub(f.value, true)
 		}
@@ -121,9 +121,10 @@ func (y *consoleMarshaller) marshalSub(v fieldValue, isParentMap bool) {
 	}
 }
 
-// quoteMapKey quotes a string so that it is suitable
-// as a key for a map.
-func quoteMapKey(key string) string {
+// quotes quotes a string so that it is suitable
+// as a key for a map or in general some output that
+// cannot span multiple lines or have weird characters.
+func quote(key string) string {
 	// strconv.Quote does not quote an empty string so we need this.
 	if key == "" {
 		return `""`

context.go

@@ -0,0 +1,121 @@
+package slog
+
+import (
+	"context"
+	"fmt"
+	"go.coder.com/slog/internal/skipctx"
+	"go.opencensus.io/trace"
+	"path/filepath"
+	"runtime"
+	"time"
+)
+
+type entry struct {
+	time time.Time
+
+	level level
+	msg   string
+
+	component string
+
+	fn   string
+	file string
+	line int
+
+	spanCtx trace.SpanContext
+
+	fields fieldMap
+}
+
+func (ent entry) pinnedFields() string {
+	pinned := fieldMap{}
+
+	if ent.spanCtx != (trace.SpanContext{}) {
+		pinned = pinned.append("trace", fieldString(ent.spanCtx.TraceID.String()))
+		pinned = pinned.append("span", fieldString(ent.spanCtx.SpanID.String()))
+	}
+
+	return marshalFields(pinned)
+}
+
+func (ent entry) stringFields() string {
+	pinned := ent.pinnedFields()
+	fields := marshalFields(ent.fields)
+
+	if pinned == "" {
+		return fields
+	}
+
+	if fields == "" {
+		return pinned
+	}
+
+	return pinned + "\n" + fields
+}
+
+// Same as time.StampMilli but the days in the month padded by zeros.
+const timestampMilli = "Jan 02 15:04:05.000"
+
+func (ent entry) String() string {
+	var ents string
+	if ent.file != "" {
+		ents += fmt.Sprintf("%v:%v: ", filepath.Base(ent.file), ent.line)
+	}
+	ents += fmt.Sprintf("%v [%v]", ent.time.Format(timestampMilli), ent.level)
+
+	if ent.component != "" {
+		ents += fmt.Sprintf(" (%v)", quote(ent.component))
+	}
+
+	ents += fmt.Sprintf(": %v", quote(ent.msg))
+
+	fields := ent.stringFields()
+	if fields != "" {
+		// We never return with a trailing newline because Go's testing framework adds one
+		// automatically and if we include one, then we'll get two newlines.
+		// We also do not indent the fields as go's test does that automatically
+		// for extra lines in a log so if we did it here, the fields would be indented
+		// twice in test logs. So the Stderr logger indents all the fields itself.
+		ents += "\n" + fields
+	}
+
+	return ents
+}
+
+type entryConfig struct {
+	level  level
+	msg    string
+	fields []interface{}
+	skip   int
+}
+
+func (l parsedFields) entry(ctx context.Context, config entryConfig) entry {
+	l = l.withContext(ctx)
+	l = l.withFields(config.fields)
+
+	ent := entry{
+		time:      time.Now(),
+		level:     config.level,
+		component: l.component,
+		msg:       config.msg,
+		spanCtx:   trace.FromContext(ctx).SpanContext(),
+		fields:    l.fields,
+	}
+
+	file, line, fn, ok := location(config.skip + 1 + skipctx.From(ctx))
+	if ok {
+		ent.file = file
+		ent.line = line
+		ent.fn = fn
+	}
+	return ent
+}
+
+func location(skip int) (file string, line int, fn string, ok bool) {
+	pc, file, line, ok := runtime.Caller(skip + 1)
+	if !ok {
+		return "", 0, "", false
+	}
+	f := runtime.FuncForPC(pc)
+	return file, line, f.Name(), true
+}

entry.go

@@ -1,22 +1,28 @@
 package slog_test
 
-// func Example_stderr() {
-// 	ctx := context.Background()
-// 	stderrlog.Info(ctx, "my message here",
-// 		"field_name", "something or the other",
-// 		"some_map", map[string]string{
-// 			"nested_fields": "wowow",
-// 		},
-// 		"some slice", []interface{}{
-// 			1,
-// 			"foof",
-// 			"bar",
-// 			true,
-// 		},
-// 		log.Component, "test",
-// 	)
-// }
-//
+import (
+	"context"
+	"go.coder.com/slog"
+	"go.coder.com/slog/stderrlog"
+)
+
+func Example_stderr() {
+	ctx := context.Background()
+	stderrlog.Info(ctx, "my message here",
+		"field_name", "something or the other",
+		"some_map", map[string]string{
+			"nested_fields": "wowow",
+		},
+		"some slice", []interface{}{
+			1,
+			"foof",
+			"bar",
+			true,
+		},
+		slog.Component("test"),
+	)
+}
+
 // func Example_test() {
 // 	// Nil here but would be provided by the testing framework.
 // 	var t *testing.T

examples_test.go

@@ -0,0 +1,98 @@
+package slog
+
+import (
+	"context"
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+	"reflect"
+)
+
+type level string
+
+const (
+	levelDebug    level = "DEBUG"
+	levelInfo     level = "INFO"
+	levelWarn     level = "WARN"
+	levelError    level = "ERROR"
+	levelCritical level = "CRITICAL"
+	levelFatal    level = "FATAL"
+)
+
+type parsedFields struct {
+	component string
+	spanCtx   trace.SpanContext
+
+	fields fieldMap
+}
+
+func parseFields(fields []interface{}) parsedFields {
+	var l parsedFields
+
+	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++
+		}
+	}
+
+	return l
+}
+
+func (l parsedFields) appendField(k string, v interface{}) parsedFields {
+	l.fields = l.fields.append(k, reflectFieldValue(reflect.ValueOf(v)))
+	return l
+}
+
+func (l parsedFields) withFields(f []interface{}) parsedFields {
+	return l.with(parseFields(f))
+}
+
+func (l parsedFields) with(l2 parsedFields) parsedFields {
+	l = l.appendComponent(l2.component)
+	if l2.spanCtx != (trace.SpanContext{}) {
+		l.spanCtx = l2.spanCtx
+	}
+
+	l.fields = l.fields.appendFields(l2.fields)
+	return l
+}
+
+func (l parsedFields) appendComponent(name string) parsedFields {
+	if l.component == "" {
+		l.component = name
+	} else if name != "" {
+		l.component += "." + name
+	}
+	return l
+}
+
+func (l parsedFields) withContext(ctx context.Context) parsedFields {
+	l2 := fromContext(ctx)
+	if len(l2.fields) == 0 {
+		return l
+	}
+
+	return l.with(l2)
+}

fields.go

@@ -6,7 +6,7 @@ require (
 	github.com/fatih/camelcase v1.0.0
 	github.com/golang/protobuf v1.3.2
 	github.com/google/go-cmp v0.3.0
-	go.opencensus.io v0.22.1 // indirect
+	go.opencensus.io v0.22.1
 	golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7
 	google.golang.org/genproto v0.0.0-20190905072037-92dd089d5514 // indirect
 )

go.mod

@@ -0,0 +1,20 @@
+// Package skipctx contains helpers to put the frame skip level
+// into the context. Used by stderrlog and testlog helpers to
+// skip one more frame level.
+package skipctx
+
+import (
+	"context"
+)
+
+type skipKey struct{}
+
+func With(ctx context.Context, skip int) context.Context {
+	skip += From(ctx)
+	return context.WithValue(ctx, skipKey{}, skip)
+}
+
+func From(ctx context.Context) int {
+	l, _ := ctx.Value(skipKey{}).(int)
+	return l
+}