Bring back doFmtVerbLevelColor on Windows

backend.go

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

examples/example.go

@@ -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.

level.go

@@ -70,6 +70,7 @@ type moduleLeveled struct {
 	backend   Backend
 	formatter Formatter
 	once      sync.Once
+	mutex     sync.Mutex
 }
 
 // AddModuleLevel wraps a log backend with knobs to have different log levels
@@ -81,13 +82,15 @@ func AddModuleLevel(backend Backend) LeveledBackend {
 		leveled = &moduleLeveled{
 			levels:  make(map[string]Level),
 			backend: backend,
+			mutex:   sync.Mutex{},
 		}
 	}
 	return leveled
 }
 
 // GetLevel returns the log level for the given module.
 func (l *moduleLeveled) GetLevel(module string) Level {
+	l.mutex.Lock()
 	level, exists := l.levels[module]
 	if exists == false {
 		level, exists = l.levels[""]
@@ -96,12 +99,15 @@ func (l *moduleLeveled) GetLevel(module string) Level {
 			level = DEBUG
 		}
 	}
+	l.mutex.Unlock()
 	return level
 }
 
 // SetLevel sets the log level for the given module.
 func (l *moduleLeveled) SetLevel(level Level, module string) {
+	l.mutex.Lock()
 	l.levels[module] = level
+	l.mutex.Unlock()
 }
 
 // IsEnabledFor will return true if logging is enabled for the given module.

log.go

@@ -0,0 +1,58 @@
+// 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 (
+	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),
+	}
+)
+
+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

@@ -8,41 +8,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
@@ -75,35 +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]))
-	}
-}

log_windows.go

@@ -17,6 +17,8 @@ var (
 	setConsoleTextAttributeProc = kernel32DLL.NewProc("SetConsoleTextAttribute")
 )
 
+type WORD uint16
+
 // Character attributes
 // Note:
 // -- The attributes are combined to produce various colors (e.g., Blue + Green will create Cyan).
@@ -36,15 +38,15 @@ const (
 )
 
 var (
-	colors = []uint16{
+	win_colors = []uint16{
 		INFO:     fgWhite,
 		CRITICAL: fgMagenta,
 		ERROR:    fgRed,
 		WARNING:  fgYellow,
 		NOTICE:   fgGreen,
 		DEBUG:    fgCyan,
 	}
-	boldcolors = []uint16{
+	win_boldcolors = []uint16{
 		INFO:     fgWhite | fgIntensity,
 		CRITICAL: fgMagenta | fgIntensity,
 		ERROR:    fgRed | fgIntensity,
@@ -84,7 +86,7 @@ func NewLogBackend(out io.Writer, prefix string, flag int) *LogBackend {
 func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error {
 	if b.Color && b.f != nil {
 		buf := &bytes.Buffer{}
-		setConsoleTextAttribute(b.f, colors[level])
+		setConsoleTextAttribute(b.f, win_colors[level])
 		buf.Write([]byte(rec.Formatted(calldepth + 1)))
 		err := b.Logger.Output(calldepth+2, buf.String())
 		setConsoleTextAttribute(b.f, fgWhite)
@@ -100,8 +102,3 @@ func setConsoleTextAttribute(f file, attribute uint16) bool {
 	ok, _, _ := setConsoleTextAttributeProc.Call(f.Fd(), uintptr(attribute), 0)
 	return ok != 0
 }
-
-func doFmtVerbLevelColor(layout string, level Level, output io.Writer) {
-	// TODO not supported on Windows since the io.Writer here is actually a
-	// bytes.Buffer.
-}

logger.go

@@ -167,7 +167,9 @@ func (l *Logger) log(lvl Level, format *string, args ...interface{}) {
 		return
 	}
 
+	defaultBackendMutex.Lock()
 	defaultBackend.Log(lvl, 2+l.ExtraCalldepth, record)
+	defaultBackendMutex.Unlock()
 }
 
 // Fatal is equivalent to l.Critical(fmt.Sprint()) followed by a call to os.Exit(1).