golog

package module
v0.0.0-...-7515bd3 Latest Latest
Warning

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

Go to latest
Published: Oct 9, 2017 License: MIT Imports: 13 Imported by: 0

README

golog


A new log package for go

There are several handlers :

  • StreamHandler : write log to io.Writer interface
  • SocketHandler : write log to socket
  • RotatingFileHandler : write log to file which rotating as size
  • TimeRotatingFileHandler : write log to file which rotating as time(second, minute, hour, day)
  • SentryHandler : write log to sentry(Sentry is a modern error logging and aggregation platform.)

coding

    // clear all handlers already exist
	ClearHandlers()
	
	// new a stream handler : write log to stdout
	h,_ := NewStreamHandler(os.Stdout)
	// append the handler to golog
	AppendHandler(h)
	
	// new a socket handler : it is tcp protocol, address is localhost:8989 and timeout is second
	h2,_ := NewSocketHandler("tcp", "localhost:8989", time.Second)
	AppendHandler(h2)
	
	// new a sentry handler : write log to sentry 
	c, err := raven.NewClient("xxx", nil)
	if err != nil {
		t.Error("raven.NewClient fail:" + err.Error())
	}
	h3, _ := NewSentryHandler(c)
	AppendHandler(h3)
	
	// write log to fileName
	// size of rotating is 10 bytes
	// count is 2 : max count of rotating
	h4, _ := NewSizeRotateFileHandler(fileName, 10, 2)
	AppendHandler(h4)
	
	// the log will be written to h1, h2, h3, h4
	
	Warnf("%v\n", "Warnf")
	Warnln("Warnf")
	Warnf("%v\n", "Warnf")
	Debugf("%v\n", "Debugf")
	Tracef("%v\n", "Tracef")
	Fatalf("%v\n", "Fatalf")
	
	Close()
level
//value:
LevelTrace 
LevelDebug
LevelInfo
LevelWarn
LevelError
LevelFatal

This is severity of log If you set level is LevelWarn LevelWarn, LevelError, LevelFatal are available LevelTrace, LevelDebug, LevelInfo will be ignore

you can set level like this:

golog.SetLevel(golog.LevelWarn)

flag

log header format:

//value
Ltime  	// 2006/01/02 15:04:05
Lfile	// file.go[123]
Llevel	// [Trace]

you can set flag like this:

golog.SetFlag(golog.Ltime | golog.Lfile)

Documentation

Index

Constants

View Source
const (
	WhenSecond = iota
	WhenMinute
	WhenHour
	WhenDay
)
View Source
const (
	LevelTrace = iota
	LevelDebug
	LevelInfo
	LevelWarn
	LevelError
	LevelFatal
)
View Source
const (
	Ltime  = 1 << iota // 2006/01/02 15:04:05
	Lfile              // file.go[123]
	Llevel             // [Trace]
)
View Source
const TimeFormat = "2006/01/02 15:04:05 "

Variables

View Source
var (
	ErrNoWriter = errors.New("io.Writer does not exist!")
)
View Source
var LevelName [6]string = [6]string{"TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"}

Functions

func AppendHandler

func AppendHandler(h Handler)

func ClearHandlers

func ClearHandlers()

func Close

func Close()

close and flush

func Debugf

func Debugf(format string, v ...interface{})

func Debugln

func Debugln(v ...interface{})

func Errorf

func Errorf(format string, v ...interface{})

func Errorln

func Errorln(v ...interface{})

func Fatalf

func Fatalf(format string, v ...interface{})

func Fatalln

func Fatalln(v ...interface{})

func GetFlag

func GetFlag() int

func GetLevel

func GetLevel() int

func Infof

func Infof(format string, v ...interface{})

func Infoln

func Infoln(v ...interface{})

func SetFlag

func SetFlag(flag int)

func SetLevel

func SetLevel(level int)

func Tracef

func Tracef(format string, v ...interface{})

func Traceln

func Traceln(v ...interface{})

func Warnf

func Warnf(format string, v ...interface{})

func Warnln

func Warnln(v ...interface{})

Types

type FileHandler

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

write log to a file.

func NewFileHandler

func NewFileHandler(fileName string, fileFlag int) (*FileHandler, error)

func (*FileHandler) Close

func (h *FileHandler) Close() error

func (*FileHandler) Write

func (h *FileHandler) Write(b []byte, level int) (n int, err error)

type Handler

type Handler interface {
	Write(p []byte, level int) (n int, err error)
	Close() error
}

Handler writes logs to somewhere you want

type LevelFileHandler

type LevelFileHandler struct {
}

type Logger

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

type NullHandler

type NullHandler struct {
}

NullHandler does nothing, it discards anything.

func NewNullHandler

func NewNullHandler() (*NullHandler, error)

func (*NullHandler) Close

func (h *NullHandler) Close() error

func (*NullHandler) Write

func (h *NullHandler) Write(b []byte, level int) (n int, err error)

type SentryHandler

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

func NewSentryHandler

func NewSentryHandler(dsn string) (*SentryHandler, error)

func (*SentryHandler) Close

func (h *SentryHandler) Close() error

func (*SentryHandler) Write

func (h *SentryHandler) Write(b []byte, level int) (n int, err error)

type SizeRotateFileHandler

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

#################### SizeRotateFileHandler write log a file

func NewSizeRotateFileHandler

func NewSizeRotateFileHandler(fileName string, maxBytes int64, backupCount int) (*SizeRotateFileHandler, error)

func (*SizeRotateFileHandler) Close

func (h *SizeRotateFileHandler) Close() error

func (*SizeRotateFileHandler) Write

func (h *SizeRotateFileHandler) Write(p []byte, level int) (n int, err error)

type SocketHandler

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

func NewSocketHandler

func NewSocketHandler(protocol string, addr string, timeout time.Duration) (*SocketHandler, error)

func (*SocketHandler) Close

func (h *SocketHandler) Close() error

func (*SocketHandler) Write

func (h *SocketHandler) Write(p []byte, level int) (n int, err error)

type StreamHandler

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

StreamHandler writes logs to a specified io Writer, maybe stdout, stderr, etc...

func NewStreamHandler

func NewStreamHandler(w io.Writer) (*StreamHandler, error)

func (*StreamHandler) Close

func (h *StreamHandler) Close() error

func (*StreamHandler) SetLevelWriter

func (h *StreamHandler) SetLevelWriter(level int, w io.Writer)

SetLevelWriter(level int, w io.Writer) : level : set writer from level to last LEVEL if you want to output LevelWarn,LevelError and LevelFatal to std.err

and output LevelInfo to std.out
you need to code SetLevelWriter(LevelInfo, os.Stdout) first, then SetLevelWriter(LevelWarn, os.Stderr).

func (*StreamHandler) Write

func (h *StreamHandler) Write(b []byte, level int) (n int, err error)

type TimeRotateFileHandler

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

################### TimeRotateFileHandler write log to a file,

func NewTimeRotateFileHandler

func NewTimeRotateFileHandler(baseName string, when int8, interval int) (*TimeRotateFileHandler, error)

func (*TimeRotateFileHandler) Close

func (h *TimeRotateFileHandler) Close() error

func (*TimeRotateFileHandler) Write

func (h *TimeRotateFileHandler) Write(b []byte, level int) (n int, err error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL