NewStdLog, NewStdLogAt, RedirectStdLog

Author: ccpaging

entry.go

@@ -17,6 +17,8 @@ import (
 type Entry struct {
 	rec *driver.Recorder
 	log *Logger
+
+	addSkip int
 }
 
 // NewEntry creates a new logging entry with a logger
@@ -35,6 +37,14 @@ func (e *Entry) SetPrefix(prefix string) *Entry {
 	return e
 }
 
+// AddCallerSkip increases the number of callers skipped by caller annotation.
+// When building wrappers around the logger Entry, supplying this function
+// to reporting the caller's caller information of the wrapper code.
+func (e *Entry) AddCallerSkip(addSkip int) *Entry {
+	e.addSkip = addSkip
+	return e
+}
+
 // With creates a child logger and adds structured context to it. Fields added
 // to the child don't affect the parent, and vice versa.
 func (e *Entry) With(args ...interface{}) *Entry {
@@ -73,7 +83,7 @@ func (e *Entry) Log(calldepth int, level int, arg0 interface{}, args ...interfac
 
 	if l.caller {
 		// Determine caller func - it's expensive.
-		_, r.Source, r.Line, _ = runtime.Caller(calldepth)
+		_, r.Source, r.Line, _ = runtime.Caller(calldepth + e.addSkip)
 	} else {
 		r.Source, r.Line = "", 0
 	}

global.go

@@ -0,0 +1,60 @@
+// Copyright (C) 2017, ccpaging <[email protected]>.  All rights reserved.
+
+package nxlog4go
+
+import (
+	"errors"
+
+	"github.com/ccpaging/nxlog4go/driver"
+)
+
+// GetLogger returns the default logger.
+func GetLogger() *Logger {
+	return std
+}
+
+// Finest is a wrapper for (*Logger).Finest
+func Finest(arg0 interface{}, args ...interface{}) {
+	std.Log(2, FINEST, arg0, args...)
+}
+
+// Fine is a wrapper for (*Logger).Fine
+func Fine(arg0 interface{}, args ...interface{}) {
+	std.Log(2, FINE, arg0, args...)
+}
+
+// Debug is a wrapper for (*Logger).Debug
+func Debug(arg0 interface{}, args ...interface{}) {
+	std.Log(2, DEBUG, arg0, args...)
+}
+
+// Trace is a wrapper for (*Logger).Trace
+func Trace(arg0 interface{}, args ...interface{}) {
+	std.Log(2, TRACE, arg0, args...)
+}
+
+// Info is a wrapper for (*Logger).Info
+func Info(arg0 interface{}, args ...interface{}) {
+	std.Log(2, INFO, arg0, args...)
+}
+
+// Warn is a wrapper for (*Logger).Warn
+func Warn(arg0 interface{}, args ...interface{}) error {
+	msg := driver.ArgsToString(arg0, args...)
+	std.Log(2, WARN, msg)
+	return errors.New(msg)
+}
+
+// Error is a wrapper for (*Logger).Error
+func Error(arg0 interface{}, args ...interface{}) error {
+	msg := driver.ArgsToString(arg0, args...)
+	std.Log(2, ERROR, msg)
+	return errors.New(msg)
+}
+
+// Critical is a wrapper for (*Logger).Critical
+func Critical(arg0 interface{}, args ...interface{}) error {
+	msg := driver.ArgsToString(arg0, args...)
+	std.Log(2, CRITICAL, msg)
+	return errors.New(msg)
+}

global_test.go

@@ -0,0 +1,55 @@
+// Copyright (C) 2017, ccpaging <[email protected]>.  All rights reserved.
+
+package nxlog4go
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestGloablLogger(t *testing.T) {
+	buf := new(bytes.Buffer)
+
+	global := GetLogger().SetOutput(buf).SetOptions(
+		"level", WARN,
+		"caller", true,
+		"format", "[%L] (%S) %M")
+	if global == nil {
+		t.Fatalf("GetLogger() should never return nil")
+	}
+	if global.stdf.level != WARN {
+		t.Fatalf("GetLogger() produced invalid logger (incorrect level)")
+	}
+
+	//func (l *Logger) Warn(args ...interface{}) error {}
+	if err := Warn("%s %d %#v", "Warn:", 1, []int{}); err.Error() != "Warn: 1 []int{}" {
+		t.Errorf("Warn returned invalid error: %s", err)
+	}
+	want := "[WARN] (nxlog4go/global_test.go) Warn: 1 []int{}\n"
+	if got := buf.String(); got != want {
+		t.Errorf("   got %q", got)
+		t.Errorf("  want %q", want)
+	}
+	buf.Reset()
+
+	//func (l *Logger) Error(args ...interface{}) error {}
+	if err := Error("%s %d %#v", "Error:", 10, []string{}); err.Error() != "Error: 10 []string{}" {
+		t.Errorf("Error returned invalid error: %s", err)
+	}
+	want = "[EROR] (nxlog4go/global_test.go) Error: 10 []string{}\n"
+	if got := buf.String(); got != want {
+		t.Errorf("   got %q", got)
+		t.Errorf("  want %q", want)
+	}
+	buf.Reset()
+
+	//func (l *Logger) Critical(args ...interface{}) error {}
+	if err := Critical("%s %d %#v", "Critical:", 100, []int64{}); err.Error() != "Critical: 100 []int64{}" {
+		t.Errorf("Critical returned invalid error: %s", err)
+	}
+	want = "[CRIT] (nxlog4go/global_test.go) Critical: 100 []int64{}\n"
+	if got := buf.String(); got != want {
+		t.Errorf("   got %q", got)
+		t.Errorf("  want %q", want)
+	}
+}

nxlog4go.go

@@ -103,7 +103,7 @@ const (
 type Logger struct {
 	mu      *sync.Mutex // ensures atomic writes; protects the following fields
 	prefix  string      // prefix to write at beginning of each line
-	caller  bool        // runtime caller skip
+	caller  bool        // enable or disable calling runtime.Caller(...)
 	stdf    *stdFilter
 	filters map[string]*driver.Filter // a collection of Filter
 }

nxlog4go_test.go

@@ -319,7 +319,6 @@ func BenchmarkFileWriter(b *testing.B) {
 		w.Close()
 		os.Remove(benchLogFile)
 	}()
-	b.StopTimer()
 
 	sl := NewLogger(INFO).SetOutput(w).SetOptions("format", testBenchFormat, "caller", false)
 
@@ -339,8 +338,6 @@ func BenchmarkFileUtilWriter(b *testing.B) {
 		w.Close()
 		os.Remove(benchLogFile)
 	}()
-	defer w.Close()
-	b.StopTimer()
 
 	sl := NewLogger(INFO).SetOutput(w).SetOptions("format", testBenchFormat, "caller", false)
 
@@ -357,7 +354,6 @@ func BenchmarkFileBufWriter(b *testing.B) {
 		w.Close()
 		os.Remove(benchLogFile)
 	}()
-	b.StopTimer()
 
 	sl := NewLogger(INFO).SetOutput(w).SetOptions("format", testBenchFormat, "caller", false)
 

stdlog.go

@@ -1,60 +1,93 @@
+// Copyright (c) 2016 Uber Technologies, Inc.
 // Copyright (C) 2017, ccpaging <[email protected]>.  All rights reserved.
 
 package nxlog4go
 
 import (
-	"errors"
-
-	"github.com/ccpaging/nxlog4go/driver"
+	"bytes"
+	"log"
 )
 
-// GetLogger returns the default logger.
-func GetLogger() *Logger {
-	return std
-}
-
-// Finest is a wrapper for (*Logger).Finest
-func Finest(arg0 interface{}, args ...interface{}) {
-	std.Log(2, FINEST, arg0, args...)
+// NewStdLog returns a *log.Logger which writes to the supplied logger Entry at
+// Info Level.
+func NewStdLog(e *Entry) *log.Logger {
+	logFunc := e.Info
+	return log.New(&logWriter{logFunc}, "" /* prefix */, 0 /* flags */)
 }
 
-// Fine is a wrapper for (*Logger).Fine
-func Fine(arg0 interface{}, args ...interface{}) {
-	std.Log(2, FINE, arg0, args...)
+// NewStdLogAt returns *log.Logger which writes to supplied logger Entry at
+// required level.
+func NewStdLogAt(e *Entry, level interface{}) *log.Logger {
+	logFunc := levelToFunc(e, level)
+	return log.New(&logWriter{logFunc}, "" /* prefix */, 0 /* flags */)
 }
 
-// Debug is a wrapper for (*Logger).Debug
-func Debug(arg0 interface{}, args ...interface{}) {
-	std.Log(2, DEBUG, arg0, args...)
+// RedirectStdLog redirects output from the standard library's package-global
+// logger to the supplied logger at InfoLevel. Since zap already handles caller
+// annotations, timestamps, etc., it automatically disables the standard
+// library's annotations and prefixing.
+//
+// It returns a function to restore the original prefix and flags and reset the
+// standard library's output to os.Stderr.
+func RedirectStdLog(e *Entry) func() {
+	return redirectStdLogAt(e, INFO)
 }
 
-// Trace is a wrapper for (*Logger).Trace
-func Trace(arg0 interface{}, args ...interface{}) {
-	std.Log(2, TRACE, arg0, args...)
+// RedirectStdLogAt redirects output from the standard library's package-global
+// logger to the supplied logger at the specified level. Since zap already
+// handles caller annotations, timestamps, etc., it automatically disables the
+// standard library's annotations and prefixing.
+//
+// It returns a function to restore the original prefix and flags and reset the
+// standard library's output to os.Stderr.
+func RedirectStdLogAt(e *Entry, level interface{}) func() {
+	return redirectStdLogAt(e, level)
 }
 
-// Info is a wrapper for (*Logger).Info
-func Info(arg0 interface{}, args ...interface{}) {
-	std.Log(2, INFO, arg0, args...)
+func redirectStdLogAt(e *Entry, level interface{}) func() {
+	flags := log.Flags()
+	prefix := log.Prefix()
+	writer := log.Writer()
+	log.SetFlags(0)
+	log.SetPrefix("")
+	logFunc := levelToFunc(e.AddCallerSkip(3), level)
+	log.SetOutput(&logWriter{logFunc})
+	return func() {
+		log.SetFlags(flags)
+		log.SetPrefix(prefix)
+		log.SetOutput(writer)
+	}
 }
 
-// Warn is a wrapper for (*Logger).Warn
-func Warn(arg0 interface{}, args ...interface{}) error {
-	msg := driver.ArgsToString(arg0, args...)
-	std.Log(2, WARN, msg)
-	return errors.New(msg)
+func levelToFunc(e *Entry, level interface{}) func(interface{}, ...interface{}) {
+	n := Level(INFO).Int(level)
+	switch n {
+	case FINEST:
+		return e.Finest
+	case FINE:
+		return e.Fine
+	case DEBUG:
+		return e.Debug
+	case TRACE:
+		return e.Trace
+	case INFO:
+		return e.Info
+	case WARN:
+		return e.Warn
+	case ERROR:
+		return e.Error
+	case CRITICAL:
+		return e.Critical
+	}
+	return e.Info
 }
 
-// Error is a wrapper for (*Logger).Error
-func Error(arg0 interface{}, args ...interface{}) error {
-	msg := driver.ArgsToString(arg0, args...)
-	std.Log(2, ERROR, msg)
-	return errors.New(msg)
+type logWriter struct {
+	logFunc func(msg interface{}, args ...interface{})
 }
 
-// Critical is a wrapper for (*Logger).Critical
-func Critical(arg0 interface{}, args ...interface{}) error {
-	msg := driver.ArgsToString(arg0, args...)
-	std.Log(2, CRITICAL, msg)
-	return errors.New(msg)
+func (l *logWriter) Write(p []byte) (int, error) {
+	p = bytes.TrimSpace(p)
+	l.logFunc(string(p))
+	return len(p), nil
 }