.github: add golangci lint

Author: jschaf

.github/workflows/lint.yaml

@@ -0,0 +1,18 @@
+name: Lint
+on: push
+jobs:
+  golangci:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Run
+        uses: golangci/golangci-lint-action@v7
+        with:
+          version: v2.1.5

.github/workflows/test.yaml

@@ -0,0 +1,28 @@
+name: Test
+on: push
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - run: go test -race ./...
+
+  fuzz:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - run: go test -fuzztime 15s -fuzz=Fuzz ./trace

.golangci.yaml

@@ -0,0 +1,58 @@
+#file: noinspection SpellCheckingInspection
+version: "2"
+linters:
+  enable:
+    - depguard
+    - dupword
+    - durationcheck
+    - errchkjson
+    - errname
+    - errorlint
+    - exhaustive
+    - exptostd
+    - forcetypeassert
+    - gocheckcompilerdirectives
+    - gochecknoglobals
+    - gochecknoinits
+    - gochecksumtype
+    - gocritic
+    - godot
+    - godox
+    - gosec
+    - intrange
+    - mirror
+    - misspell
+    - nilerr
+    - nilnesserr
+    - nilnil
+    - nolintlint
+    - predeclared
+    - reassign
+    - recvcheck
+    - sloglint
+    - unconvert
+    - unparam
+    - usestdlibvars
+    - usetesting
+    - wastedassign
+    - wrapcheck
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+  settings:
+    depguard:
+      rules:
+        Main:
+          list-mode: strict
+          allow: ["$gostd", "github.com/jschaf/observe"]
+    wrapcheck:
+      extra-ignore-sigs: ["json.Marshal("]
+formatters:
+  enable:
+    - gofumpt
+  exclusions:
+    generated: lax

internal/difftest/assert_same.go

@@ -15,14 +15,18 @@ func AssertSame[T any](t *testing.T, msg string, want, got T) {
 	}
 }
 
+//golint:ignore:asciicheck
 func diff(a, b any) string {
 	switch x := a.(type) {
 	case string:
-		return diffString(x, b.(string))
+		y, _ := b.(string)
+		return diffString(x, y)
 	case time.Time:
-		return diffTime(x, b.(time.Time))
+		y, _ := b.(time.Time)
+		return diffTime(x, y)
 	case http.Header:
-		if equalMaps(x, b.(http.Header)) {
+		y, _ := b.(http.Header)
+		if equalMaps(x, y) {
 			return ""
 		}
 		return fmt.Sprintf("- %v\n+ %v", a, b)

internal/epoch/nanos.go

@@ -6,6 +6,8 @@ import (
 )
 
 // Nanos is the nanoseconds since the Unix epoch.
+//
+//nolint:recvcheck
 type Nanos int64
 
 // NewNanos converts a time.Time to Nanos. If the time is zero, it
@@ -35,9 +37,9 @@ func (u Nanos) ToTime() time.Time {
 // Returns true if the value was swapped.
 //
 //goland:noinspection GoMixedReceiverTypes
-func (u *Nanos) SwapIfZero(new Nanos) bool {
+func (u *Nanos) SwapIfZero(ns Nanos) bool {
 	p := (*int64)(u)
-	return atomic.CompareAndSwapInt64(p, 0, int64(new))
+	return atomic.CompareAndSwapInt64(p, 0, int64(ns))
 }
 
 //goland:noinspection GoMixedReceiverTypes

internal/hextbl/hex.go

@@ -42,7 +42,7 @@ func ParseUint64(s string) (uint64, bool) {
 	var n uint64
 	invalidMark := byte(0)
 	for i := 0; i < len(s); i += 4 {
-		shift := uint((15 - i) * 4)
+		shift := uint((15 - i) * 4) //nolint:gosec
 		n |= uint64(Reverse[s[i]]) << shift
 		n |= uint64(Reverse[s[i+1]]) << (shift - 4)
 		n |= uint64(Reverse[s[i+2]]) << (shift - 8)

internal/hextbl/hex_test.go

@@ -34,6 +34,7 @@ func TestReadByte(t *testing.T) {
 		})
 	}
 }
+
 func TestParseUint64(t *testing.T) {
 	tests := []struct {
 		name   string

internal/hextbl/uint128.go

@@ -21,7 +21,7 @@ func ParseUint128(s string) (Uint128, bool) {
 	var hi, lo uint64
 	invalidMark := byte(0)
 	for i := 0; i < 16; i += 4 {
-		shift := uint((15 - i) * 4)
+		shift := uint((15 - i) * 4) //nolint:gosec
 
 		hi |= uint64(Reverse[s[i]]) << shift
 		hi |= uint64(Reverse[s[i+1]]) << (shift - 4)

internal/tty/color.go

@@ -4,6 +4,7 @@ import (
 	"os"
 )
 
+//nolint:gochecknoglobals
 var noColor = os.Getenv("NO_COLOR") != "" || os.Getenv("TERM") == "dumb"
 
 // Foreground colors.
@@ -21,6 +22,7 @@ const (
 	White   Color = 37
 )
 
+//nolint:gochecknoglobals
 var codes = [8]string{
 	"\x1b[30m",
 	"\x1b[31m",

log/log_test.go

@@ -2,7 +2,6 @@ package log
 
 import (
 	"bytes"
-	"context"
 	"log/slog"
 	"regexp"
 	"strings"
@@ -15,7 +14,7 @@ import (
 const textTimeRE = `\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}(Z|[+-]\d{2}:\d{2})`
 
 func TestLogTextHandler(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 
 	var buf bytes.Buffer
 	slog.SetDefault(slog.New(slog.NewTextHandler(&buf, nil)))

log/logdev/buffer.go

@@ -9,6 +9,8 @@ import "sync"
 type Buffer []byte
 
 // Having an initial size gives a dramatic speedup.
+//
+//nolint:gochecknoglobals
 var bufPool = sync.Pool{
 	New: func() any {
 		b := make([]byte, 0, 1024)
@@ -17,7 +19,8 @@ var bufPool = sync.Pool{
 }
 
 func NewBuffer() *Buffer {
-	return bufPool.Get().(*Buffer)
+	buf, _ := bufPool.Get().(*Buffer)
+	return buf
 }
 
 func (b *Buffer) Free() {

log/logdev/dev_handler.go

@@ -176,6 +176,8 @@ func appendValue(buf *Buffer, v slog.Value) {
 		default:
 			_, _ = fmt.Fprint(buf, a)
 		}
+	case slog.KindGroup, slog.KindLogValuer:
+		panic(fmt.Sprintf("unsupported kind: %s", v.Kind()))
 	default:
 		panic(fmt.Sprintf("bad kind: %s", v.Kind()))
 	}

log/logdev/dev_handler_test.go

@@ -2,7 +2,6 @@ package log
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"log/slog"
 	"os"
@@ -22,11 +21,11 @@ func TestDevHandler_Sample(t *testing.T) {
 	l.Debug("debug level message", slog.String("attribute3", "value3"))
 	l.Warn("warning level with multiple attrs", slog.Float64("pi", 3.14), slog.Bool("isTest", true))
 	l.Error("error level message", slog.Any("details", map[string]any{"key": "value"}))
-	l.Info("info level message that is really, really, long", slog.String("attribute1", "value1"), slog.Int("attribute2", 42))
+	l.Info("info level message that is really, long", slog.String("attribute1", "value1"), slog.Int("attribute2", 42))
 }
 
 func TestDevHandler_Handle(t *testing.T) {
-	ctx := context.Background()
+	ctx := t.Context()
 	buf := &bytes.Buffer{}
 	h := &DevHandler{w: buf}
 
@@ -44,7 +43,7 @@ func TestDevHandler_Handle(t *testing.T) {
 }
 
 func BenchmarkDevHandler_Handle(b *testing.B) {
-	ctx := context.Background()
+	ctx := b.Context()
 	buf := &bytes.Buffer{}
 	h := &DevHandler{w: buf}
 

trace/id.go

@@ -45,10 +45,13 @@ func (s SpanID) String() string {
 	return string(a[:])
 }
 
-//goland:noinspection SpellCheckingInspection
+func genTraceID() TraceID {
+	return TraceID{n: hextbl.Uint128{Hi: rand.Uint64(), Lo: rand.Uint64()}} //nolint:gosec
+}
 
-func genTraceID() TraceID { return TraceID{n: hextbl.Uint128{Hi: rand.Uint64(), Lo: rand.Uint64()}} }
-func genSpanID() SpanID   { return SpanID{n: rand.Uint64() & math.MaxInt64} }
+func genSpanID() SpanID {
+	return SpanID{n: rand.Uint64() & math.MaxInt64} //nolint:gosec
+}
 
 // ParseTraceID parses a 32-character hex string into a TraceID.
 func ParseTraceID(s string) (TraceID, error) {

trace/id_test.go

@@ -31,7 +31,7 @@ func TestTraceID_String(t *testing.T) {
 	}
 
 	t.Run("random", func(t *testing.T) {
-		for i := 0; i < 1000; i++ {
+		for range 1000 {
 			id := genTraceID()
 			if !id.IsValid() {
 				continue
@@ -156,7 +156,7 @@ func TestSpanID_String(t *testing.T) {
 	}
 
 	t.Run("random", func(t *testing.T) {
-		for i := 0; i < 1000; i++ {
+		for range 1000 {
 			id := genSpanID()
 			if !id.IsValid() {
 				continue

trace/span_test.go

@@ -42,7 +42,7 @@ func TestSpan_End_Race(t *testing.T) {
 	for range readerCount {
 		go func() {
 			defer wg.Done()
-			for j := 0; j < 5; j++ {
+			for range 5 {
 				_ = span.IsRecording()
 				_ = span.EndTime()
 				time.Sleep(1 * time.Millisecond) // delay to allow interleaving

trace/state.go

@@ -68,31 +68,39 @@ func ParseState(ts string) (State, error) {
 
 	// Check for dupe keys. We only check duplicated lengths.
 	if dupeLenBits.hasAny() {
-		// Note: we're checking for duplicates in the hash of the key, not the key
-		// itself. We may have false positives, but it should be vanishingly rare.
-		var hashes = [32]keyHash{}
-		idx := 0
-		for pos := range splitMembers(ts) {
-			if pos.isEmpty() {
-				continue
-			}
-			if !dupeLenBits.hasBit(pos.keyLen()) {
-				continue
-			}
-			hashes[idx] = pos.hashKey(ts)
-			idx++
-		}
-		slices.Sort(hashes[:idx]) // sorting 32 entries is 2x faster than a map
-		for i := 1; i < idx; i++ {
-			if hashes[i] == hashes[i-1] {
-				return State{}, fmt.Errorf("duplicate key")
-			}
+		err := checkDupes(ts, dupeLenBits)
+		if err != nil {
+			return State{}, err
 		}
 	}
 
 	return State{s: ts, isClean: isClean}, nil
 }
 
+func checkDupes(ts string, dupeLenBits *bitset) error {
+	// Note: we're checking for duplicates in the hash of the key, not the key
+	// itself. We may have false positives, but it should be vanishingly rare.
+	hashes := [32]keyHash{}
+	idx := 0
+	for pos := range splitMembers(ts) {
+		if pos.isEmpty() {
+			continue
+		}
+		if !dupeLenBits.hasBit(pos.keyLen()) {
+			continue
+		}
+		hashes[idx] = pos.hashKey(ts)
+		idx++
+	}
+	slices.Sort(hashes[:idx]) // sorting 32 entries is 2x faster than a map
+	for i := 1; i < idx; i++ {
+		if hashes[i] == hashes[i-1] {
+			return fmt.Errorf("duplicate key")
+		}
+	}
+	return nil
+}
+
 // Members iterate over each key-value list-member in the tracestate string.
 func (st State) Members() iter.Seq2[string, string] {
 	return func(yield func(string, string) bool) {
@@ -153,7 +161,7 @@ type memberPos struct {
 func (p memberPos) isEmpty() bool                 { return p == memberPos{} }
 func (p memberPos) isValid() bool                 { return p.keyLo < p.keyHi && p.valLo < p.valHi }
 func (p memberPos) startsAt(offs int) bool        { return p.keyLo == offs }
-func (p memberPos) keyLen() uint64                { return uint64(p.keyHi - p.keyLo) }
+func (p memberPos) keyLen() uint64                { return uint64(p.keyHi - p.keyLo) } //nolint:gosec
 func (p memberPos) last() int                     { return p.valHi }
 func (p memberPos) memberString(ts string) string { return ts[p.keyLo:p.valHi] }
 func (p memberPos) keyString(ts string) string    { return ts[p.keyLo:p.keyHi] }
@@ -269,7 +277,6 @@ func checkKeyRest(ts string, lo, hi int) bool {
 		}
 	}
 	return true
-
 }
 
 func checkVal(ts string, pos memberPos) bool {

trace/state_test.go

@@ -276,7 +276,7 @@ func TestParseState(t *testing.T) {
 
 func genTracestateSequence(tmpl string, n int) string {
 	seq := make([]string, n)
-	for i := 0; i < n; i++ {
+	for i := range n {
 		seq[i] = strings.ReplaceAll(tmpl, "%d", strconv.Itoa(i))
 	}
 	return strings.Join(seq, ",")