Bring back doFmtVerbLevelColor on Windows

.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  schedule:
+    # Run daily at 2 AM UTC to check for new vulnerabilities
+    - cron: "0 2 * * *"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    timeout-minutes: 15
+    strategy:
+      matrix:
+        go-version: [1.25.x, 1.24.x, 1.23.x]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - uses: actions/setup-go@v6
+        with:
+          go-version: ${{ matrix.go-version }}
+          cache: true
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v9
+        with:
+          version: v2.7.2
+
+      - name: Build
+        run: go build -v ./...
+
+      - name: Run govulncheck
+        uses: golang/govulncheck-action@v1
+        with:
+          go-version-input: ${{ matrix.go-version }}
+
+      - name: Test
+        run: go test -race ./...

.golangci.yml

@@ -0,0 +1,66 @@
+version: "2"
+
+run:
+  timeout: 5m
+  tests: true
+
+formatters:
+  enable:
+    - gofumpt
+
+linters:
+  enable:
+    # Core recommended linters
+    - errcheck # Checks for unchecked errors
+    - govet # Go vet checks
+    - ineffassign # Detects ineffectual assignments
+    - staticcheck # Advanced static analysis
+    - unused # Finds unused code
+
+    # Code quality
+    - misspell # Finds commonly misspelled words
+    - unconvert # Unnecessary type conversions (already enabled in original)
+    - unparam # Finds unused function parameters
+    - gocritic # Various checks (already enabled in original)
+    - revive # Fast, configurable linter (already enabled in original)
+
+    # Security and best practices
+    - gosec # Security-focused linter
+    - bodyclose # Checks HTTP response body closed
+    - noctx # Finds HTTP requests without context
+
+  settings:
+    gocritic:
+      disabled-checks:
+        - ifElseChain
+        - elseif
+
+    govet:
+      enable-all: true
+      disable:
+        - shadow
+        - fieldalignment
+
+    revive:
+      enable-all-rules: false
+
+  exclusions:
+    rules:
+      # Exclude specific revive rules
+      - linters:
+          - revive
+        text: "package-comments"
+
+      - linters:
+          - revive
+        text: "exported"
+
+      # Exclude specific staticcheck rules
+      - linters:
+          - staticcheck
+        text: "ST1005"
+
+      # Exclude specific gocritic rules
+      - linters:
+          - gocritic
+        text: "ifElseChain"

README.md

@@ -1,6 +1,7 @@
 ## Golang logging library
 
-[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/op/go-logging) [![build](https://img.shields.io/travis/op/go-logging.svg?style=flat)](https://travis-ci.org/op/go-logging)
+[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/op/go-logging)
+[![Build Status](https://github.com/keybase/go-logging/actions/workflows/ci.yml/badge.svg)](https://github.com/keybase/go-logging/actions)
 
 Package logging implements a logging infrastructure for Go. Its output format
 is customizable and supports different logging backends like syslog, file and
@@ -72,11 +73,11 @@ func main() {
 
 ## Installing
 
-### Using *go get*
+### Using _go get_
 
     $ go get github.com/op/go-logging
 
-After this command *go-logging* is ready to use. Its source will be in:
+After this command _go-logging_ is ready to use. Its source will be in:
 
     $GOPATH/src/pkg/github.com/op/go-logging
 
@@ -90,4 +91,4 @@ For docs, see http://godoc.org/github.com/op/go-logging or run:
 
 ## Additional resources
 
-* [wslog](https://godoc.org/github.com/cryptix/go/logging/wslog) -- exposes log messages through a WebSocket.
+- [wslog](https://godoc.org/github.com/cryptix/go/logging/wslog) -- exposes log messages through a WebSocket.

backend.go

@@ -4,8 +4,15 @@
 
 package logging
 
+import (
+	"sync"
+)
+
 // defaultBackend is the backend used for all logging calls.
-var defaultBackend LeveledBackend
+var (
+	defaultBackend      LeveledBackend
+	defaultBackendMutex sync.RWMutex
+)
 
 // Backend is the interface which a log backend need to implement to be able to
 // be used as a logging backend.
@@ -23,6 +30,8 @@ func SetBackend(backends ...Backend) LeveledBackend {
 		backend = MultiLogger(backends...)
 	}
 
+	defaultBackendMutex.Lock()
+	defer defaultBackendMutex.Unlock()
 	defaultBackend = AddModuleLevel(backend)
 	return defaultBackend
 }

example_test.go

@@ -6,7 +6,7 @@ func Example() {
 	// This call is for testing purposes and will set the time to unix epoch.
 	InitForTesting(DEBUG)
 
-	var log = MustGetLogger("example")
+	log := MustGetLogger("example")
 
 	// For demo purposes, create two backend for os.Stdout.
 	//
@@ -18,7 +18,7 @@ func Example() {
 	// For messages written to backend2 we want to add some additional
 	// information to the output, including the used log level and the name of
 	// the function.
-	var format = MustStringFormatter(
+	format := MustStringFormatter(
 		`%{time:15:04:05.000} %{shortfunc} %{level:.1s} %{message}`,
 	)
 	backend2Formatter := NewBackendFormatter(backend2, format)

examples/example.go

@@ -3,7 +3,7 @@ package main
 import (
 	"os"
 
-	"github.com/op/go-logging"
+	"github.com/keybase/go-logging"
 )
 
 var log = logging.MustGetLogger("example")
@@ -27,7 +27,8 @@ func main() {
 	// For demo purposes, create two backend for os.Stderr.
 	backend1 := logging.NewLogBackend(os.Stderr, "", 0)
 	backend2 := logging.NewLogBackend(os.Stderr, "", 0)
-
+	backend1.Color = true
+	backend2.Color = true
 	// For messages written to backend2 we want to add some additional
 	// information to the output, including the used log level and the name of
 	// the function.

format.go

@@ -105,7 +105,7 @@ type Formatter interface {
 	Format(calldepth int, r *Record, w io.Writer) error
 }
 
-// formatter is used by all backends unless otherwise overriden.
+// formatter is used by all backends unless otherwise overridden.
 var formatter struct {
 	sync.RWMutex
 	def Formatter
@@ -154,17 +154,18 @@ type stringFormatter struct {
 // The verbs:
 //
 // General:
-//     %{id}        Sequence number for log message (uint64).
-//     %{pid}       Process id (int)
-//     %{time}      Time when log occurred (time.Time)
-//     %{level}     Log level (Level)
-//     %{module}    Module (string)
-//     %{program}   Basename of os.Args[0] (string)
-//     %{message}   Message (string)
-//     %{longfile}  Full file name and line number: /a/b/c/d.go:23
-//     %{shortfile} Final file name element and line number: d.go:23
-//     %{callpath}  Callpath like main.a.b.c...c  "..." meaning recursive call ~. meaning truncated path
-//     %{color}     ANSI color based on log level
+//
+//	%{id}        Sequence number for log message (uint64).
+//	%{pid}       Process id (int)
+//	%{time}      Time when log occurred (time.Time)
+//	%{level}     Log level (Level)
+//	%{module}    Module (string)
+//	%{program}   Basename of os.Args[0] (string)
+//	%{message}   Message (string)
+//	%{longfile}  Full file name and line number: /a/b/c/d.go:23
+//	%{shortfile} Final file name element and line number: d.go:23
+//	%{callpath}  Callpath like main.a.b.c...c  "..." meaning recursive call ~. meaning truncated path
+//	%{color}     ANSI color based on log level
 //
 // For normal types, the output can be customized by using the 'verbs' defined
 // in the fmt package, eg. '%{id:04d}' to make the id output be '%04d' as the
@@ -191,13 +192,14 @@ type stringFormatter struct {
 // future.
 //
 // Experimental:
-//     %{longpkg}   Full package path, eg. github.com/go-logging
-//     %{shortpkg}  Base package path, eg. go-logging
-//     %{longfunc}  Full function name, eg. littleEndian.PutUint32
-//     %{shortfunc} Base function name, eg. PutUint32
-//     %{callpath}  Call function path, eg. main.a.b.c
+//
+//	%{longpkg}   Full package path, eg. github.com/go-logging
+//	%{shortpkg}  Base package path, eg. go-logging
+//	%{longfunc}  Full function name, eg. littleEndian.PutUint32
+//	%{shortfunc} Base function name, eg. PutUint32
+//	%{callpath}  Call function path, eg. main.a.b.c
 func NewStringFormatter(format string) (Formatter, error) {
-	var fmter = &stringFormatter{}
+	fmter := &stringFormatter{}
 
 	// Find the boundaries of all %{vars}
 	matches := formatRe.FindAllStringSubmatchIndex(format, -1)
@@ -271,41 +273,36 @@ func (f *stringFormatter) add(verb fmtVerb, layout string) {
 	f.parts = append(f.parts, part{verb, layout})
 }
 
-func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) error {
+func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) (err error) {
 	for _, part := range f.parts {
-		if part.verb == fmtVerbStatic {
-			output.Write([]byte(part.layout))
-		} else if part.verb == fmtVerbTime {
-			output.Write([]byte(r.Time.Format(part.layout)))
-		} else if part.verb == fmtVerbLevelColor {
+		switch part.verb {
+		case fmtVerbStatic:
+			_, _ = output.Write([]byte(part.layout))
+		case fmtVerbTime:
+			_, _ = output.Write([]byte(r.Time.Format(part.layout)))
+		case fmtVerbLevelColor:
 			doFmtVerbLevelColor(part.layout, r.Level, output)
-		} else if part.verb == fmtVerbCallpath {
+		case fmtVerbCallpath:
 			depth, err := strconv.Atoi(part.layout)
 			if err != nil {
 				depth = 0
 			}
-			output.Write([]byte(formatCallpath(calldepth+1, depth)))
-		} else {
+			_, _ = output.Write([]byte(formatCallpath(calldepth+1, depth)))
+		default:
 			var v interface{}
 			switch part.verb {
 			case fmtVerbLevel:
 				v = r.Level
-				break
 			case fmtVerbID:
 				v = r.ID
-				break
 			case fmtVerbPid:
 				v = pid
-				break
 			case fmtVerbProgram:
 				v = program
-				break
 			case fmtVerbModule:
 				v = r.Module
-				break
 			case fmtVerbMessage:
 				v = r.Message()
-				break
 			case fmtVerbLongfile, fmtVerbShortfile:
 				_, file, line, ok := runtime.Caller(calldepth + 1)
 				if !ok {
@@ -327,7 +324,10 @@ func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) err
 			default:
 				panic("unhandled format part")
 			}
-			fmt.Fprintf(output, part.layout, v)
+			_, err = fmt.Fprintf(output, part.layout, v)
+			if err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -400,7 +400,7 @@ type backendFormatter struct {
 }
 
 // NewBackendFormatter creates a new backend which makes all records that
-// passes through it beeing formatted by the specific formatter.
+// passes through it being formatted by the specific formatter.
 func NewBackendFormatter(b Backend, f Formatter) Backend {
 	return &backendFormatter{b, f}
 }