Bring back doFmtVerbLevelColor on Windows

.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.21.x, 1.22.x, 1.23.x]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: ${{ matrix.go-version }}
+      - uses: actions/checkout@v3
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          version: v1.63
+      - run: go vet ./...
+      - run: go test ./...

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,13 @@
 
 package logging
 
+import (
+	"sync"
+)
+
 // defaultBackend is the backend used for all logging calls.
 var defaultBackend LeveledBackend
+var 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 +28,8 @@ func SetBackend(backends ...Backend) LeveledBackend {
 		backend = MultiLogger(backends...)
 	}
 
+	defaultBackendMutex.Lock()
+	defer defaultBackendMutex.Unlock()
 	defaultBackend = AddModuleLevel(backend)
 	return defaultBackend
 }

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

@@ -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,11 +192,12 @@ 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{}
 
@@ -274,38 +276,32 @@ func (f *stringFormatter) add(verb fmtVerb, layout string) {
 func (f *stringFormatter) Format(calldepth int, r *Record, output io.Writer) error {
 	for _, part := range f.parts {
 		if part.verb == fmtVerbStatic {
-			output.Write([]byte(part.layout))
+			_, _ = output.Write([]byte(part.layout))
 		} else if part.verb == fmtVerbTime {
-			output.Write([]byte(r.Time.Format(part.layout)))
+			_, _ = output.Write([]byte(r.Time.Format(part.layout)))
 		} else if part.verb == fmtVerbLevelColor {
 			doFmtVerbLevelColor(part.layout, r.Level, output)
 		} else if part.verb == fmtVerbCallpath {
 			depth, err := strconv.Atoi(part.layout)
 			if err != nil {
 				depth = 0
 			}
-			output.Write([]byte(formatCallpath(calldepth+1, depth)))
+			_, _ = output.Write([]byte(formatCallpath(calldepth+1, depth)))
 		} else {
 			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 {

format_test.go

@@ -109,13 +109,13 @@ func TestFormatFuncName(t *testing.T) {
 			"main",
 			"main",
 			"main"},
-		{"github.com/op/go-logging.func·001",
-			"github.com/op/go-logging",
+		{"github.com/keybase/go-logging.func·001",
+			"github.com/keybase/go-logging",
 			"go-logging",
 			"func·001",
 			"func·001"},
-		{"github.com/op/go-logging.stringFormatter.Format",
-			"github.com/op/go-logging",
+		{"github.com/keybase/go-logging.stringFormatter.Format",
+			"github.com/keybase/go-logging",
 			"go-logging",
 			"stringFormatter.Format",
 			"Format"},

go.mod

@@ -0,0 +1,3 @@
+module github.com/keybase/go-logging
+
+go 1.21

level.go

@@ -66,6 +66,7 @@ type LeveledBackend interface {
 }
 
 type moduleLeveled struct {
+	sync.RWMutex
 	levels    map[string]Level
 	backend   Backend
 	formatter Formatter
@@ -88,11 +89,13 @@ func AddModuleLevel(backend Backend) LeveledBackend {
 
 // GetLevel returns the log level for the given module.
 func (l *moduleLeveled) GetLevel(module string) Level {
+	l.RLock()
+	defer l.RUnlock()
 	level, exists := l.levels[module]
-	if exists == false {
+	if !exists {
 		level, exists = l.levels[""]
 		// no configuration exists, default to debug
-		if exists == false {
+		if !exists {
 			level = DEBUG
 		}
 	}
@@ -101,6 +104,8 @@ func (l *moduleLeveled) GetLevel(module string) Level {
 
 // SetLevel sets the log level for the given module.
 func (l *moduleLeveled) SetLevel(level Level, module string) {
+	l.Lock()
+	defer l.Unlock()
 	l.levels[module] = level
 }
 

log.go

@@ -0,0 +1,57 @@
+// Copyright 2013, Örjan Persson. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logging
+
+import (
+	"fmt"
+	"io"
+)
+
+type color int
+
+const (
+	_ = iota + 30
+	colorRed
+	colorGreen
+	colorYellow
+	_
+	colorMagenta
+	colorCyan
+)
+
+var (
+	colors = []string{
+		CRITICAL: colorSeq(colorMagenta),
+		ERROR:    colorSeq(colorRed),
+		WARNING:  colorSeq(colorYellow),
+		NOTICE:   colorSeq(colorGreen),
+		DEBUG:    colorSeq(colorCyan),
+	}
+	boldcolors = []string{
+		CRITICAL: colorSeqBold(colorMagenta),
+		ERROR:    colorSeqBold(colorRed),
+		WARNING:  colorSeqBold(colorYellow),
+		NOTICE:   colorSeqBold(colorGreen),
+		DEBUG:    colorSeqBold(colorCyan),
+	}
+)
+
+func colorSeq(color color) string {
+	return fmt.Sprintf("\033[%dm", int(color))
+}
+
+func colorSeqBold(color color) string {
+	return fmt.Sprintf("\033[%d;1m", int(color))
+}
+
+func doFmtVerbLevelColor(layout string, level Level, output io.Writer) {
+	if layout == "bold" {
+		_, _ = output.Write([]byte(boldcolors[level]))
+	} else if layout == "reset" {
+		_, _ = output.Write([]byte("\033[0m"))
+	} else {
+		_, _ = output.Write([]byte(colors[level]))
+	}
+}

log_nix.go

@@ -1,3 +1,4 @@
+//go:build !windows
 // +build !windows
 
 // Copyright 2013, Örjan Persson. All rights reserved.
@@ -8,41 +9,10 @@ package logging
 
 import (
 	"bytes"
-	"fmt"
 	"io"
 	"log"
 )
 
-type color int
-
-const (
-	ColorBlack = iota + 30
-	ColorRed
-	ColorGreen
-	ColorYellow
-	ColorBlue
-	ColorMagenta
-	ColorCyan
-	ColorWhite
-)
-
-var (
-	colors = []string{
-		CRITICAL: ColorSeq(ColorMagenta),
-		ERROR:    ColorSeq(ColorRed),
-		WARNING:  ColorSeq(ColorYellow),
-		NOTICE:   ColorSeq(ColorGreen),
-		DEBUG:    ColorSeq(ColorCyan),
-	}
-	boldcolors = []string{
-		CRITICAL: ColorSeqBold(ColorMagenta),
-		ERROR:    ColorSeqBold(ColorRed),
-		WARNING:  ColorSeqBold(ColorYellow),
-		NOTICE:   ColorSeqBold(ColorGreen),
-		DEBUG:    ColorSeqBold(ColorCyan),
-	}
-)
-
 // LogBackend utilizes the standard log module.
 type LogBackend struct {
 	Logger      *log.Logger
@@ -74,36 +44,3 @@ func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error {
 
 	return b.Logger.Output(calldepth+2, rec.Formatted(calldepth+1))
 }
-
-// ConvertColors takes a list of ints representing colors for log levels and
-// converts them into strings for ANSI color formatting
-func ConvertColors(colors []int, bold bool) []string {
-	converted := []string{}
-	for _, i := range colors {
-		if bold {
-			converted = append(converted, ColorSeqBold(color(i)))
-		} else {
-			converted = append(converted, ColorSeq(color(i)))
-		}
-	}
-
-	return converted
-}
-
-func ColorSeq(color color) string {
-	return fmt.Sprintf("\033[%dm", int(color))
-}
-
-func ColorSeqBold(color color) string {
-	return fmt.Sprintf("\033[%d;1m", int(color))
-}
-
-func doFmtVerbLevelColor(layout string, level Level, output io.Writer) {
-	if layout == "bold" {
-		output.Write([]byte(boldcolors[level]))
-	} else if layout == "reset" {
-		output.Write([]byte("\033[0m"))
-	} else {
-		output.Write([]byte(colors[level]))
-	}
-}