logex

README

logex

an enhanced for logrus. logex append the context call info to the log.

Since v1.2.0, logex allows switching the logging backend transparently.

Features

• Pre-setup logging backends with clickeable caller info: logrus or zap
• Generic logging interface to cover the various logging backends via: log.Logger, build.New(config)

Usage

Build logger transparently

We provide the ability to switch logging backends transparently now.

A sample config file looks like:

app:

  # runmode: devel  # devel, prod

  logger:
    # The field 'level' will be reset to "debug" while the app is started up within a debugger
    # available values are:
    #   "disable"/"off", "panic", "fatal", "error", "warn", "info", "debug", "trace"
    level:  info
    format: text                  # text, json, logfmt, ...
    backend: sugar                # zap, sugar(sugared-zap) or logrus
    target: file                  # console, file
    directory: /var/log/$APPNAME

Load it to Config structure:

import "github.com/hedzr/log"
var config *log.LoggerConfig = log.NewLoggerConfig()
// ...

And build the backend:

import "github.com/hedzr/logex/build"
logger := build.New(config)
logger.Debugf("int value = %v", intVal)

Or build a logger backend directly

import "github.com/hedzr/logex/logx/logrus"
logrus.New(level string, traceMode, debugMode bool, opts ...Opt)

import "github.com/hedzr/logex/logx/zap"
zap.New(level string, traceMode, debugMode bool, opts ...Opt)

import "github.com/hedzr/logex/logx/zap/sugar"
sugar.New(level string, traceMode, debugMode bool, opts ...Opt)

Legacy tools

Enable logrus

import "github.com/hedzr/logex"

func init(){
    logex.Enable()
    // Or:
    logex.EnableWith(logrus.DebugLevel)
}

Ignore the extra caller frames

If you are writing logging func wrappers, you might ignore the extra caller frames for those wrappers:

func wrong(err error, fmt string, args interface{}) {
    logrus.WithError(err).WithFields(logrus.Fields{
        logex.SKIP: 1,  // ignore wrong() frame
    }).Errorf(fmt, args)
}

func wrongInner(err error, fields logrus.Fields, fmt string, args interface{}) {
    logrus.WithError(err).WithFields(fields).Errorf(fmt, args)
}

func wrongwrong(err error, fmt string, args interface{}) {
    wrongInner(err, logrus.Fields{
        logex.SKIP: 2,  // ignore wrongwrong() and wrongInner() frame
    }, fmt, args...)
}

For go test

make logrus works in go test

The codes is copied from:

https://github.com/sirupsen/logrus/issues/834

And in a test function, you could code now:

   func TestFoo(t *testing.T) {
     defer logex.CaptureLog(t).Release()
     // …
   }

ACK

• logrus

LICENSE

MIT

Documentation

Overview

Package logex is a logging helper library which append the context call info to logging output for locating

Index

• Constants
• func Enable()
• func EnableWith(lvl log.Level, opts ...Option)
• func GetDebugMode() bool
• func GetLevel() log.Level
• func GetTraceMode() bool
• func InDebugging() bool
• func SetDebugMode(b bool)
• func SetTraceMode(b bool)
• func SetupLoggingFormat(format string, logexSkipFrames int)
• type LogCapturer
  • func CaptureLog(t *testing.T) LogCapturer
• type Option

Constants

const (
	// AppName const
	AppName = "logex"
	// Version const
	Version = "1.2.15"
	// VersionInt const
	VersionInt = 0x01020e
)

const SKIP = formatter.SKIP

Functions

func Enable

func Enable()

func EnableWith

func EnableWith(lvl log.Level, opts ...Option)

func GetDebugMode

func GetDebugMode() bool

GetDebugMode return the debug boolean flag generally

func GetLevel

func GetLevel() log.Level

func GetTraceMode

func GetTraceMode() bool

GetTraceMode return the trace boolean flag generally

func InDebugging

func InDebugging() bool

InDebugging check if the delve debugger presents

func SetDebugMode

func SetDebugMode(b bool)

SetDebugMode set the debug boolean flag generally

func SetTraceMode

func SetTraceMode(b bool)

SetTraceMode set the trace boolean flag generally

func SetupLoggingFormat

func SetupLoggingFormat(format string, logexSkipFrames int)

Types

type LogCapturer

type LogCapturer interface {
	Release()
}

LogCapturer reroutes testing.T log output

func CaptureLog

func CaptureLog(t *testing.T) LogCapturer

CaptureLog redirects logrus output to testing.Log

type Option

type Option func()