Add golangci-lint (#9)

lucacome · web-flow · commit c83290547c9a · 2026-04-14T19:31:29.000-07:00
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
@@ -0,0 +1,43 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+defaults:
+  run:
+    shell: bash
+
+concurrency:
+  group: ${{ github.ref_name }}-lint
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: Go Lint
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+
+      - name: Setup Golang Environment
+        uses: actions/setup-go@v6
+        with:
+          go-version: stable
+
+      - name: Lint Go
+        uses: golangci/golangci-lint-action@v9
+
+  actionlint:
+    name: Actionlint
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+
+      - name: Lint Actions
+        uses: reviewdog/action-actionlint@v1
diff --git a/.golangci.yml b/.golangci.yml
@@ -0,0 +1,102 @@
+version: "2"
+linters:
+  default: none
+  enable:
+    - asasalint
+    - asciicheck
+    - bidichk
+    - contextcheck
+    - copyloopvar
+    - dupword
+    - durationcheck
+    - errcheck
+    - errchkjson
+    - errname
+    - errorlint
+    - fatcontext
+    - forcetypeassert
+    - gocheckcompilerdirectives
+    - gochecksumtype
+    - gocritic
+    - godot
+    - gosec
+    - gosmopolitan
+    - govet
+    - ineffassign
+    - intrange
+    - makezero
+    - misspell
+    - musttag
+    - nilerr
+    - noctx
+    - nolintlint
+    - paralleltest
+    - perfsprint
+    - prealloc
+    - predeclared
+    - reassign
+    - revive
+    - staticcheck
+    - tagalign
+    - thelper
+    - tparallel
+    - unconvert
+    - unparam
+    - unused
+    - usestdlibvars
+    - wastedassign
+    - whitespace
+  settings:
+    govet:
+      enable-all: true
+    misspell:
+      locale: US
+    revive:
+      rules:
+        - name: blank-imports
+        - name: context-as-argument
+        - name: context-keys-type
+        - name: dot-imports
+        - name: empty-block
+        - name: error-naming
+        - name: error-return
+        - name: error-strings
+        - name: errorf
+        - name: exported
+        - name: increment-decrement
+        - name: indent-error-flow
+        - name: package-comments
+        - name: range
+        - name: receiver-naming
+        - name: redefines-builtin-id
+        - name: superfluous-else
+        - name: time-naming
+        - name: unexported-return
+        - name: unreachable-code
+        - name: var-declaration
+        - name: var-naming
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/log/log.go b/log/log.go
@@ -12,7 +12,7 @@ import (
 
 // DEBUG
 
-// DebugWithContext logs on debug level and trace based on the context span if it exists
+// DebugWithContext logs on debug level and trace based on the context span if it exists.
 func DebugWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	DebugWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -23,14 +23,14 @@ func DebugWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	logSpan(span, log, fields...)
 }
 
-// Debug logs on debug level
+// Debug logs on debug level.
 func Debug(log string, fields ...zapcore.Field) {
 	zap.L().Debug(log, fields...)
 }
 
 // INFO
 
-// InfoWithContext logs on info level and trace based on the context span if it exists
+// InfoWithContext logs on info level and trace based on the context span if it exists.
 func InfoWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	InfoWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -39,17 +39,16 @@ func InfoWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 func InfoWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	Info(log, fields...)
 	logSpan(span, log, fields...)
-
 }
 
-// Info logs on info level
+// Info logs on info level.
 func Info(log string, fields ...zapcore.Field) {
 	zap.L().Info(log, fields...)
 }
 
 // WARN
 
-// WarnWithContext logs on warn level and trace based on the context span if it exists
+// WarnWithContext logs on warn level and trace based on the context span if it exists.
 func WarnWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	WarnWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -58,17 +57,16 @@ func WarnWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 func WarnWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	Warn(log, fields...)
 	logSpan(span, log, fields...)
-
 }
 
-// Warn logs on warn level
+// Warn logs on warn level.
 func Warn(log string, fields ...zapcore.Field) {
 	zap.L().Warn(log, fields...)
 }
 
 // ERROR
 
-// ErrorWithContext logs on error level and trace based on the context span if it exists
+// ErrorWithContext logs on error level and trace based on the context span if it exists.
 func ErrorWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	ErrorWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -79,14 +77,14 @@ func ErrorWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	logSpan(span, log, fields...)
 }
 
-// Error logs on error level
+// Error logs on error level.
 func Error(log string, fields ...zapcore.Field) {
 	zap.L().Error(log, fields...)
 }
 
 // DPANIC
 
-// DPanicWithContext logs on dPanic level and trace based on the context span if it exists
+// DPanicWithContext logs on dPanic level and trace based on the context span if it exists.
 func DPanicWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	DPanicWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -97,14 +95,14 @@ func DPanicWithSpan(span opentracing.Span, log string, fields ...zapcore.Field)
 	DPanic(log, fields...)
 }
 
-// DPanic logs on dPanic level
+// DPanic logs on dPanic level.
 func DPanic(log string, fields ...zapcore.Field) {
 	zap.L().DPanic(log, fields...)
 }
 
 // PANIC
 
-// PanicWithContext logs on panic level and trace based on the context span if it exists
+// PanicWithContext logs on panic level and trace based on the context span if it exists.
 func PanicWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	PanicWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -115,12 +113,12 @@ func PanicWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	Panic(log, fields...)
 }
 
-// Panic logs on panic level
+// Panic logs on panic level.
 func Panic(log string, fields ...zapcore.Field) {
 	zap.L().Panic(log, fields...)
 }
 
-// FatalWithContext logs on fatal level and trace based on the context span if it exists
+// FatalWithContext logs on fatal level and trace based on the context span if it exists.
 func FatalWithContext(ctx context.Context, log string, fields ...zapcore.Field) {
 	FatalWithSpan(opentracing.SpanFromContext(ctx), log, fields...)
 }
@@ -131,14 +129,14 @@ func FatalWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	Fatal(log, fields...)
 }
 
-// Fatal logs on fatal level
+// Fatal logs on fatal level.
 func Fatal(log string, fields ...zapcore.Field) {
 	zap.L().Fatal(log, fields...)
 }
 
 func logSpan(span opentracing.Span, log string, fields ...zapcore.Field) {
 	if span != nil {
-		opentracingFields := make([]opentracinglog.Field, len(fields)+1)
+		opentracingFields := make([]opentracinglog.Field, 0, len(fields)+1)
 		if log != "" {
 			opentracingFields = append(opentracingFields, opentracinglog.String("event", log))
 		}
diff --git a/utils/fields.go b/utils/fields.go
@@ -25,33 +25,38 @@ func ZapFieldsToOpentracing(zapFields ...zapcore.Field) []opentracinglog.Field {
 // input Zap field.
 func ZapFieldToOpentracing(zapField zapcore.Field) opentracinglog.Field {
 	switch zapField.Type {
-
 	case zapcore.BoolType:
 		val := false
 		if zapField.Integer >= 1 {
 			val = true
 		}
 		return opentracinglog.Bool(zapField.Key, val)
 	case zapcore.Float32Type:
-		return opentracinglog.Float32(zapField.Key, math.Float32frombits(uint32(zapField.Integer)))
+		return opentracinglog.Float32(zapField.Key, math.Float32frombits(uint32(zapField.Integer))) //nolint:gosec // G115: intentional bit-pattern conversion matching zap's encoding
 	case zapcore.Float64Type:
-		return opentracinglog.Float64(zapField.Key, math.Float64frombits(uint64(zapField.Integer)))
+		return opentracinglog.Float64(zapField.Key, math.Float64frombits(uint64(zapField.Integer))) //nolint:gosec // G115: intentional bit-pattern conversion matching zap's encoding
 	case zapcore.Int64Type:
-		return opentracinglog.Int64(zapField.Key, int64(zapField.Integer))
+		return opentracinglog.Int64(zapField.Key, zapField.Integer)
 	case zapcore.Int32Type:
-		return opentracinglog.Int32(zapField.Key, int32(zapField.Integer))
+		return opentracinglog.Int32(zapField.Key, int32(zapField.Integer)) //nolint:gosec // G115: value was originally int32, stored as int64 by zap
 	case zapcore.StringType:
 		return opentracinglog.String(zapField.Key, zapField.String)
 	case zapcore.StringerType:
-		return opentracinglog.String(zapField.Key, zapField.Interface.(fmt.Stringer).String())
+		if s, ok := zapField.Interface.(fmt.Stringer); ok {
+			return opentracinglog.String(zapField.Key, s.String())
+		}
+		return opentracinglog.Object(zapField.Key, zapField.Interface)
 	case zapcore.Uint64Type:
-		return opentracinglog.Uint64(zapField.Key, uint64(zapField.Integer))
+		return opentracinglog.Uint64(zapField.Key, uint64(zapField.Integer)) //nolint:gosec // G115: value was originally uint64, stored as int64 by zap
 	case zapcore.Uint32Type:
-		return opentracinglog.Uint32(zapField.Key, uint32(zapField.Integer))
+		return opentracinglog.Uint32(zapField.Key, uint32(zapField.Integer)) //nolint:gosec // G115: value was originally uint32, stored as int64 by zap
 	case zapcore.DurationType:
 		return opentracinglog.String(zapField.Key, time.Duration(zapField.Integer).String())
 	case zapcore.ErrorType:
-		return opentracinglog.Error(zapField.Interface.(error))
+		if err, ok := zapField.Interface.(error); ok {
+			return opentracinglog.Error(err)
+		}
+		return opentracinglog.Object(zapField.Key, zapField.Interface)
 	default:
 		return opentracinglog.Object(zapField.Key, zapField.Interface)
 	}
diff --git a/utils/fields_test.go b/utils/fields_test.go
@@ -18,7 +18,7 @@ func (s stringer) String() string {
 }
 
 func TestFieldsConversion(t *testing.T) {
-
+	t.Parallel()
 	TestData := []struct {
 		ZapField         zapcore.Field
 		OpenTracingField opentracinglog.Field
@@ -83,6 +83,24 @@ func TestFieldsConversion(t *testing.T) {
 			zap.Bool("namespace", true),
 			opentracinglog.Bool("namespace", true),
 		},
+		// StringerType: Interface payload is not a fmt.Stringer – should fall back to Object.
+		{
+			zapcore.Field{Key: "stringer", Type: zapcore.StringerType, Interface: 42},
+			opentracinglog.Object("stringer", 42),
+		},
+		{
+			zapcore.Field{Key: "stringer", Type: zapcore.StringerType, Interface: nil},
+			opentracinglog.Object("stringer", nil),
+		},
+		// ErrorType: Interface payload is not an error – should fall back to Object.
+		{
+			zapcore.Field{Key: "err", Type: zapcore.ErrorType, Interface: "not an error"},
+			opentracinglog.Object("err", "not an error"),
+		},
+		{
+			zapcore.Field{Key: "err", Type: zapcore.ErrorType, Interface: nil},
+			opentracinglog.Object("err", nil),
+		},
 	}
 
 	for _, data := range TestData {
@@ -97,5 +115,4 @@ func TestFieldsConversion(t *testing.T) {
 			t.Errorf("Expected same value. Got %s but expected %s", result.Value(), data.OpenTracingField.Value())
 		}
 	}
-
 }

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ import (`
`12`	`12`
`13`	`13`	`// DEBUG`
`14`	`14`
`15`		`-// DebugWithContext logs on debug level and trace based on the context span if it exists`
	`15`	`+// DebugWithContext logs on debug level and trace based on the context span if it exists.`
`16`	`16`	`func DebugWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`17`	`17`	`DebugWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`18`	`18`	`}`
`@@ -23,14 +23,14 @@ func DebugWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`23`	`23`	`logSpan(span, log, fields...)`
`24`	`24`	`}`
`25`	`25`
`26`		`-// Debug logs on debug level`
	`26`	`+// Debug logs on debug level.`
`27`	`27`	`func Debug(log string, fields ...zapcore.Field) {`
`28`	`28`	`zap.L().Debug(log, fields...)`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// INFO`
`32`	`32`
`33`		`-// InfoWithContext logs on info level and trace based on the context span if it exists`
	`33`	`+// InfoWithContext logs on info level and trace based on the context span if it exists.`
`34`	`34`	`func InfoWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`35`	`35`	`InfoWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`36`	`36`	`}`
`@@ -39,17 +39,16 @@ func InfoWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`39`	`39`	`func InfoWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`40`	`40`	`Info(log, fields...)`
`41`	`41`	`logSpan(span, log, fields...)`
`42`		`-`
`43`	`42`	`}`
`44`	`43`
`45`		`-// Info logs on info level`
	`44`	`+// Info logs on info level.`
`46`	`45`	`func Info(log string, fields ...zapcore.Field) {`
`47`	`46`	`zap.L().Info(log, fields...)`
`48`	`47`	`}`
`49`	`48`
`50`	`49`	`// WARN`
`51`	`50`
`52`		`-// WarnWithContext logs on warn level and trace based on the context span if it exists`
	`51`	`+// WarnWithContext logs on warn level and trace based on the context span if it exists.`
`53`	`52`	`func WarnWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`54`	`53`	`WarnWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`55`	`54`	`}`
`@@ -58,17 +57,16 @@ func WarnWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`58`	`57`	`func WarnWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`59`	`58`	`Warn(log, fields...)`
`60`	`59`	`logSpan(span, log, fields...)`
`61`		`-`
`62`	`60`	`}`
`63`	`61`
`64`		`-// Warn logs on warn level`
	`62`	`+// Warn logs on warn level.`
`65`	`63`	`func Warn(log string, fields ...zapcore.Field) {`
`66`	`64`	`zap.L().Warn(log, fields...)`
`67`	`65`	`}`
`68`	`66`
`69`	`67`	`// ERROR`
`70`	`68`
`71`		`-// ErrorWithContext logs on error level and trace based on the context span if it exists`
	`69`	`+// ErrorWithContext logs on error level and trace based on the context span if it exists.`
`72`	`70`	`func ErrorWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`73`	`71`	`ErrorWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`74`	`72`	`}`
`@@ -79,14 +77,14 @@ func ErrorWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`79`	`77`	`logSpan(span, log, fields...)`
`80`	`78`	`}`
`81`	`79`
`82`		`-// Error logs on error level`
	`80`	`+// Error logs on error level.`
`83`	`81`	`func Error(log string, fields ...zapcore.Field) {`
`84`	`82`	`zap.L().Error(log, fields...)`
`85`	`83`	`}`
`86`	`84`
`87`	`85`	`// DPANIC`
`88`	`86`
`89`		`-// DPanicWithContext logs on dPanic level and trace based on the context span if it exists`
	`87`	`+// DPanicWithContext logs on dPanic level and trace based on the context span if it exists.`
`90`	`88`	`func DPanicWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`91`	`89`	`DPanicWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`92`	`90`	`}`
`@@ -97,14 +95,14 @@ func DPanicWithSpan(span opentracing.Span, log string, fields ...zapcore.Field)`
`97`	`95`	`DPanic(log, fields...)`
`98`	`96`	`}`
`99`	`97`
`100`		`-// DPanic logs on dPanic level`
	`98`	`+// DPanic logs on dPanic level.`
`101`	`99`	`func DPanic(log string, fields ...zapcore.Field) {`
`102`	`100`	`zap.L().DPanic(log, fields...)`
`103`	`101`	`}`
`104`	`102`
`105`	`103`	`// PANIC`
`106`	`104`
`107`		`-// PanicWithContext logs on panic level and trace based on the context span if it exists`
	`105`	`+// PanicWithContext logs on panic level and trace based on the context span if it exists.`
`108`	`106`	`func PanicWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`109`	`107`	`PanicWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`110`	`108`	`}`
`@@ -115,12 +113,12 @@ func PanicWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`115`	`113`	`Panic(log, fields...)`
`116`	`114`	`}`
`117`	`115`
`118`		`-// Panic logs on panic level`
	`116`	`+// Panic logs on panic level.`
`119`	`117`	`func Panic(log string, fields ...zapcore.Field) {`
`120`	`118`	`zap.L().Panic(log, fields...)`
`121`	`119`	`}`
`122`	`120`
`123`		`-// FatalWithContext logs on fatal level and trace based on the context span if it exists`
	`121`	`+// FatalWithContext logs on fatal level and trace based on the context span if it exists.`
`124`	`122`	`func FatalWithContext(ctx context.Context, log string, fields ...zapcore.Field) {`
`125`	`123`	`FatalWithSpan(opentracing.SpanFromContext(ctx), log, fields...)`
`126`	`124`	`}`
`@@ -131,14 +129,14 @@ func FatalWithSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`131`	`129`	`Fatal(log, fields...)`
`132`	`130`	`}`
`133`	`131`
`134`		`-// Fatal logs on fatal level`
	`132`	`+// Fatal logs on fatal level.`
`135`	`133`	`func Fatal(log string, fields ...zapcore.Field) {`
`136`	`134`	`zap.L().Fatal(log, fields...)`
`137`	`135`	`}`
`138`	`136`
`139`	`137`	`func logSpan(span opentracing.Span, log string, fields ...zapcore.Field) {`
`140`	`138`	`if span != nil {`
`141`		`- opentracingFields := make([]opentracinglog.Field, len(fields)+1)`
	`139`	`+ opentracingFields := make([]opentracinglog.Field, 0, len(fields)+1)`
`142`	`140`	`if log != "" {`
`143`	`141`	`opentracingFields = append(opentracingFields, opentracinglog.String("event", log))`
`144`	`142`	`}`