log

type ContextCauseHook ¶

type ContextCauseHook struct{}

ContextCauseHook attaches context.Cause.

func (h *ContextCauseHook) Fire(entry *logrus.Entry) error

func (h *ContextCauseHook) Levels() []logrus.Level

type Factory ¶

type Factory struct {
	Level         Level
	DefaultFields logrus.Fields
	Hooks         []logrus.Hook
	Logger        *Logger
}

func NewFactory(level Level, hooks ...logrus.Hook) *Factory

func (f *Factory) New(name string) *Logger

func (f *Factory) ReplaceHooks(hooks ...logrus.Hook) *Factory

type FormatHook ¶

type FormatHook struct {
	MaskPatterns []MaskPattern
	Mask         string
}

func (h *FormatHook) Fire(entry *logrus.Entry) error

func (h *FormatHook) Levels() []logrus.Level

type Level ¶

type Level string

const (
	LevelDebug Level = "debug"
	LevelInfo  Level = "info"
	LevelWarn  Level = "warn"
	LevelError Level = "error"
)

func ParseLevel(s string) (Level, error)

func (l Level) Logrus() logrus.Level

type Logger ¶

type Logger = logrus.Entry

type LoggingSkippable ¶

type LoggingSkippable interface{ SkipLogging() bool }

type MaskPattern ¶

type MaskPattern interface {
	Mask(s string, mask string) string
}

type PlainMaskPattern ¶

type PlainMaskPattern struct {
	Pattern string
}

func NewPlainMaskPattern(s string) PlainMaskPattern

func (p PlainMaskPattern) Mask(s string, mask string) string

type RegexMaskPattern ¶

type RegexMaskPattern struct {
	Pattern *regexp.Regexp
}

func NewRegexMaskPattern(expr string) RegexMaskPattern

func (p RegexMaskPattern) Mask(s string, mask string) string

type SkipLoggingHook ¶

type SkipLoggingHook struct{}

func (SkipLoggingHook) Fire(entry *logrus.Entry) error

func (SkipLoggingHook) Levels() []logrus.Level

type StackHook ¶

type StackHook struct{}

StackHook attaches call stack to entries with level >= error.

func (h *StackHook) Fire(entry *logrus.Entry) error

func (h *StackHook) Levels() []logrus.Level

type WriterHook ¶

type WriterHook struct {
	Writer    io.Writer
	Formatter logrus.Formatter
}

WriterHook replaces logger.Out. Since logger.Out works with logger.Formatter, We have to replicate the behavior here. The reason for WriterHook to exist is to call our Ignore() to filter out unwanted entry.

func NewWriterHook(w io.Writer) *WriterHook

func (h *WriterHook) Fire(entry *logrus.Entry) error

func (h *WriterHook) Levels() []logrus.Level