logrus_mate

package module
v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 3, 2020 License: Apache-2.0 Imports: 8 Imported by: 0

README

Logrus Mate

Logrus mate is a tool for Logrus, it will help you to initial logger by config, including Formatter, Hook，Level and Output .

If you more prefer old version, you could checkout tag v1.0.0

Example

Example 1:

Hijack logrus.StandardLogger()

package main

import (
    "github.com/sirupsen/logrus"
    "github.com/big-uncle/logrus_mate"
)

func main() {
    logrus_mate.Hijack(
        logrus.StandardLogger(),
        logrus_mate.ConfigString(
            `{formatter.name = "json"}`,
        ),
    )
    
    logrus.WithField("Field", "A").Debugln("Hello JSON")
}

Example 2:

Create new logger from mate:

package main

import (
    "github.com/big-uncle/logrus_mate"
)

func main() {
    mate, _ := logrus_mate.NewLogrusMate(
        logrus_mate.ConfigString(
            `{ mike {formatter.name = "json"} }`,
        ),
    )
    
    mikeLoger := mate.Logger("mike")
    mikeLoger.Errorln("Hello Error Level from Mike and my formatter is json")
}

Example 3:

Hi jack logger by mate

package main

import (
    "github.com/sirupsen/logrus"
    "github.com/big-uncle/logrus_mate"
)

func main() {
    mate, _ := logrus_mate.NewLogrusMate(
        logrus_mate.ConfigString(
            `{ mike {formatter.name = "json"} }`,
        ),
    )

    mate.Hijack(
        logrus.StandardLogger(),
        "mike",
    )
    
    logrus.Println("hello std logger is hijack by mike")
}

Example 4:

Fallback the ConfigString

package main

import (
    "github.com/sirupsen/logrus"
    "github.com/big-uncle/logrus_mate"
)

func main() {
    mate, _ := logrus_mate.NewLogrusMate(
        logrus_mate.ConfigString(
            `{ mike {formatter.name = "json"} }`,
        ),
        logrus_mate.ConfigFile(
            "mate.conf", // { mike {formatter.name = "text"} }
        ),
    )

    mate.Hijack(
        logrus.StandardLogger(),
        "mike",
    )
    
    logrus.Println("hello std logger is hijack by mike")
}

the json formatter is used

Example 5:

Fallback config while hijack

package main

import (
    "github.com/sirupsen/logrus"
    "github.com/big-uncle/logrus_mate"
)

func main() {
    mate, _ := logrus_mate.NewLogrusMate(
        logrus_mate.ConfigFile(
            "mate.conf", // { mike {formatter.name = "text"} }
        ),
    )

    mate.Hijack(logrus.StandardLogger(),
        "mike",
        logrus_mate.ConfigString(
            `{formatter.name = "json"}`,
        ),
    )

    logrus.Errorln("hello std logger is hijack by mike")
}

the json formatter is used

currently we are using https://github.com/go-akka/configuration for logger config, it will more powerful config format for human read, you also could set your own config provider

Hooks
Hook Options
Airbrake project-id api-key env
Syslog network address priority tag
BugSnag api-key
Slackrus url levels channel emoji username
Graylog address facility extra
Mail app-name host port from to username password
File filename max-lines max-size daily max-days rotate level
BearyChat url levels channel user markdown async
LFSHook path-map { error = "logs/error.log" ... }
sls README

When we need use above hooks, we need import these package as follow:

import _ "github.com/big-uncle/logrus_mate/hooks/syslog"
import _ "github.com/big-uncle/logrus_mate/hooks/mail"

If you want write your own hook, you just need todo as follow:

package myhook

import (
    "github.com/big-uncle/logrus_mate"
)

type MyHookConfig struct {
    Address  string
}

func init() {
    logrus_mate.RegisterHook("myhook", NewMyHook)
}

func NewMyHook(config logrus_mate.Configuration) (hook logrus.Hook, err error) {
    conf := MyHookConfig{}
    if config!=nil {
        conf.Address = config.GetString("address")
    }

    // write your hook logic code here

    return
}
Formatters

internal formatters:

Formatter Options Output Example
null
text force-colors disable-colors disable-timestamp full-timestamp timestamp-format disable-sorting DEBU[0000] Hello Default Logrus Mate
json timestamp-format {"level":"info","msg":"Hello, I am A Logger from jack","time":"2015-10-18T21:24:19+08:00"}

3rd formatters:

Formatter Output Example
logstash [Removed]

When we need use 3rd formatter, we need import these package as follow:

import _ "github.com/big-uncle/logrus_mate/formatters/xxx"

If you want write your own formatter, you just need todo as follow:

package myformatter

import (
    "github.com/big-uncle/logrus_mate"
)

type MyFormatterConfig struct {
    Address  string `json:"address"`
}

func init() {
    logrus_mate.RegisterFormatter("myformatter", NewMyFormatter)
}

func NewMyFormatter(config logrus_mate.Configuration) (formatter logrus.Formatter, err error) {
    conf := MyFormatterConfig{}
    if config!=nil {
        conf.Address=config.GetString("address")
    }

    // write your formatter logic code here

    return
}
Writers

internal writers (output):

  • stdout
  • stderr
  • null

3rd writers:

Writer Description
redisio just for demo, it will output into redis, the key type is list
rotatelogs write log to file , configs: clock location link-name rotation-time max-age

When we need use 3rd writer, we need import these package as follow:

import _ "github.com/big-uncle/logrus_mate/writers/redisio"

If you want write your own writer, you just need todo as follow:

package mywriter

import (
    "io"

    "github.com/big-uncle/logrus_mate"
)

type MyWriterConfig struct {
    Address  string `json:"address"`
}

func init() {
    logrus_mate.RegisterWriter("mywriter", NewMyWriter)
}

func NewMyWriter(config logrus_mate.Configuration) (writer io.Writer, err error) {
    conf := MyWriterConfig{}
    if config!=nil {
        conf.Address=config.GetString("address")
    }

    // write your writer logic code here

    return
}
Config Provider

The default config provider is HOCON, you could use your own config provider, just implement the following interface{}

type ConfigurationProvider interface {
    LoadConfig(filename string) Configuration
    ParseString(cfgStr string) Configuration
}

type Configuration interface {
    GetBoolean(path string, defaultVal ...bool) bool
    GetByteSize(path string) *big.Int
    GetInt32(path string, defaultVal ...int32) int32
    GetInt64(path string, defaultVal ...int64) int64
    GetString(path string, defaultVal ...string) string
    GetFloat32(path string, defaultVal ...float32) float32
    GetFloat64(path string, defaultVal ...float64) float64
    GetTimeDuration(path string, defaultVal ...time.Duration) time.Duration
    GetTimeDurationInfiniteNotAllowed(path string, defaultVal ...time.Duration) time.Duration
    GetBooleanList(path string) []bool
    GetFloat32List(path string) []float32
    GetFloat64List(path string) []float64
    GetInt32List(path string) []int32
    GetInt64List(path string) []int64
    GetByteList(path string) []byte
    GetStringList(path string) []string
    GetConfig(path string) Configuration
    WithFallback(fallback Configuration)
    HasPath(path string) bool
    Keys() []string
}

set your own config provider

package main

import (
    "github.com/gogap/config"
    "github.com/big-uncle/logrus_mate"
    "github.com/sirupsen/logrus"
)

func main() {
    mate, _ := logrus_mate.NewLogrusMate(
        logrus_mate.ConfigString(
            `{ mike {formatter.name = "json"} }`,
        ),
        logrus_mate.ConfigFile(
            "mate.conf", // { mike {formatter.name = "text"} }
        ),
        logrus_mate.ConfigProvider(
            &config.HOCONConfigProvider{}, // this is defualt provider if you did not configurate
        ),
    )

    mate.Hijack(
        logrus.StandardLogger(),
        "mike",
    )

    logrus.Println("hello std logger is hijack by mike")
}

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrLoggerNotExist = errors.New("logger not exist")
)

Functions

func Formatters 

func Formatters() []string

func Hijack 

func Hijack(logger *logrus.Logger, opts ...Option) (err error)

func Hooks 

func Hooks() []string

func NewFormatter 

func NewFormatter(name string, config config.Configuration) (formatter logrus.Formatter, err error)

func NewHook 

func NewHook(name string, config config.Configuration) (hook logrus.Hook, err error)

func NewJSONFormatter 

func NewJSONFormatter(config config.Configuration) (formatter logrus.Formatter, err error)

func NewLogger 

func NewLogger(opts ...Option) (logger *logrus.Logger, err error)

func NewNullFormatter 

func NewNullFormatter(config config.Configuration) (formatter logrus.Formatter, err error)

func NewNullWriter 

func NewNullWriter(conf config.Configuration) (writer io.Writer, err error)

func NewStderrWriter 

func NewStderrWriter(config.Configuration) (writer io.Writer, err error)

func NewStdoutWriter 

func NewStdoutWriter(config.Configuration) (writer io.Writer, err error)

func NewTextFormatter 

func NewTextFormatter(config config.Configuration) (formatter logrus.Formatter, err error)

func NewWriter 

func NewWriter(name string, conf config.Configuration) (writer io.Writer, err error)

func RegisterFormatter 

func RegisterFormatter(name string, newFormatterFunc NewFormatterFunc)

func RegisterHook 

func RegisterHook(name string, newHookFunc NewHookFunc)

func RegisterWriter 

func RegisterWriter(name string, newWriterFunc NewWriterFunc)

func Writers 

func Writers() []string

Types

type Config 

type Config struct {
	// contains filtered or unexported fields
}

type JSONFormatterConfig 

type JSONFormatterConfig struct {
	TimestampFormat string `json:"timestamp_format"`
}

type LogrusMate 

type LogrusMate struct {
	// contains filtered or unexported fields
}

func NewLogrusMate 

func NewLogrusMate(opts ...Option) (logrusMate *LogrusMate, err error)

func (*LogrusMate) Hijack 

func (p *LogrusMate) Hijack(logger *logrus.Logger, loggerName string, opts ...Option) (err error)

func (*LogrusMate) Logger 

func (p *LogrusMate) Logger(loggerName ...string) (logger *logrus.Logger)

type NewFormatterFunc 

type NewFormatterFunc func(config.Configuration) (formatter logrus.Formatter, err error)

type NewHookFunc 

type NewHookFunc func(config.Configuration) (hook logrus.Hook, err error)

type NewWriterFunc 

type NewWriterFunc func(config.Configuration) (writer io.Writer, err error)

type NullFormatter 

type NullFormatter struct {
}

func (NullFormatter) Format 

func (NullFormatter) Format(e *logrus.Entry) ([]byte, error)

type NullWriter 

type NullWriter struct {
}

func (*NullWriter) Write 

func (w *NullWriter) Write(p []byte) (n int, err error)

type Option 

type Option func(*Config)

func ConfigFile 

func ConfigFile(fn string) Option

func ConfigProvider 

func ConfigProvider(provider config.ConfigurationProvider) Option

func ConfigString 

func ConfigString(str string) Option

func WithConfig 

func WithConfig(conf config.Configuration) Option

Source Files

View all Source files

Directories

Path Synopsis
hooks
airbrake
bearychat
bugsnag
expander
file
graylog
lfshook
mail
slack
sls
syslog
utils/caller
writers
redisio
rotatelogs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.