flogging.MustGetLogger("chaincode")

[yfhk]

// Log implements the Backend interface.
func (b *LogBackend) Log(level Level, calldepth int, rec *Record) error {
// debug.PrintStack()
if b.Color {
col := colors[level]
if len(b.ColorConfig) > int(level) && b.ColorConfig[level] != "" {
col = b.ColorConfig[level]
}

	buf := &bytes.Buffer{}
	buf.Write([]byte(col))
	buf.Write([]byte(rec.Formatted(calldepth + 1)))
	buf.Write([]byte("\033[0m"))
	// For some reason, the Go logger arbitrarily decided "2" was the correct
	// call depth...
	// return b.Logger.Output(calldepth+2, buf.String())
	fmt.Println(calldepth+2, buf.String())
	return nil
}

// return b.Logger.Output(calldepth+2, rec.Formatted(calldepth+1))
fmt.Println(calldepth+2, rec.Formatted(calldepth+1))
return nil

}

[yfhk]

"github.com/op/go-logging"

// MustGetLogger is used in place of logging.MustGetLogger to allow us to
// store a map of all modules and submodules that have loggers in the system.
func MustGetLogger(module string) *logging.Logger {
l := logging.MustGetLogger(module)
lock.Lock()
defer lock.Unlock()
modules[module] = GetModuleLevel(module)
return l
}

[yfhk]

// MustGetLogger is like GetLogger but panics if the logger can't be created.
// It simplifies safe initialization of a global logger for eg. a package.
func MustGetLogger(module string) *Logger {
logger, err := GetLogger(module)
if err != nil {
panic("logger: " + module + ": " + err.Error())
}
return logger
}

[yfhk]

func (l *Logger) log(lvl Level, format *string, args ...interface{}) {
// if !l.IsEnabledFor(lvl) {
// return
// }

// Create the logging record and pass it in to the backend
record := &Record{
	ID:     atomic.AddUint64(&sequenceNo, 1),
	Time:   timeNow(),
	Module: l.Module,
	Level:  lvl,
	fmt:    format,
	Args:   args,
}

// TODO use channels to fan out the records to all backends?
// TODO in case of errors, do something (tricky)

// calldepth=2 brings the stack up to the caller of the level
// methods, Info(), Fatal(), etc.
// ExtraCallDepth allows this to be extended further up the stack in case we
// are wrapping these methods, eg. to expose them package level
if l.haveBackend {
	l.backend.Log(lvl, 2+l.ExtraCalldepth, record)
	return
}

defaultBackend.Log(lvl, 2+l.ExtraCalldepth, record)

}

// Fatal is equivalent to l.Critical(fmt.Sprint()) followed by a call to os.Exit(1).
func (l *Logger) Fatal(args ...interface{}) {
l.log(CRITICAL, nil, args...)
os.Exit(1)
}

// Fatalf is equivalent to l.Critical followed by a call to os.Exit(1).
func (l *Logger) Fatalf(format string, args ...interface{}) {
l.log(CRITICAL, &format, args...)
os.Exit(1)
}

// Panic is equivalent to l.Critical(fmt.Sprint()) followed by a call to panic().
func (l *Logger) Panic(args ...interface{}) {
l.log(CRITICAL, nil, args...)
panic(fmt.Sprint(args...))
}

// Panicf is equivalent to l.Critical followed by a call to panic().
func (l *Logger) Panicf(format string, args ...interface{}) {
l.log(CRITICAL, &format, args...)
panic(fmt.Sprintf(format, args...))
}

// Critical logs a message using CRITICAL as log level.
func (l *Logger) Critical(args ...interface{}) {
l.log(CRITICAL, nil, args...)
}

// Criticalf logs a message using CRITICAL as log level.
func (l *Logger) Criticalf(format string, args ...interface{}) {
l.log(CRITICAL, &format, args...)
}

// Error logs a message using ERROR as log level.
func (l *Logger) Error(args ...interface{}) {
l.log(ERROR, nil, args...)
}

// Errorf logs a message using ERROR as log level.
func (l *Logger) Errorf(format string, args ...interface{}) {
l.log(ERROR, &format, args...)
}

// Warning logs a message using WARNING as log level.
func (l *Logger) Warning(args ...interface{}) {
l.log(WARNING, nil, args...)
}

// Warningf logs a message using WARNING as log level.
func (l *Logger) Warningf(format string, args ...interface{}) {
l.log(WARNING, &format, args...)
}

// Notice logs a message using NOTICE as log level.
func (l *Logger) Notice(args ...interface{}) {
l.log(NOTICE, nil, args...)
}

// Noticef logs a message using NOTICE as log level.
func (l *Logger) Noticef(format string, args ...interface{}) {
l.log(NOTICE, &format, args...)
}

// Info logs a message using INFO as log level.
func (l *Logger) Info(args ...interface{}) {
l.log(INFO, nil, args...)
}

// Infof logs a message using INFO as log level.
func (l *Logger) Infof(format string, args ...interface{}) {
l.log(INFO, &format, args...)
}

// Debug logs a message using DEBUG as log level.
func (l *Logger) Debug(args ...interface{}) {
l.log(DEBUG, nil, args...)
}

// Debugf logs a message using DEBUG as log level.
func (l *Logger) Debugf(format string, args ...interface{}) {
l.log(DEBUG, &format, args...)
}

func init() {
Reset()
}