logging

README

Golang logging library

---

Package logging implements a logging infrastructure. It supports different MessageHandler like StreamHandler for console and FileHandler for file output; Every MessageHandler can have different MessageFormatter and MessageFilter.

Example

package main

import (
	"github.com/gamelife1314/logging"
	"os"
)

func main() {
	logger := logging.GetDefaultLogger()
	logger.Debug("hello world, %s", "logging")
	logger.Info("hello world, %s", "logging")
	logger.Notice("hello world, %s", "logging")
	logger.Warning("hello world, %s", "logging")
	logger.Error("hello world, %s", "logging")
	logger.Critical("hello world, %s", "logging")

	logFile, _ := os.OpenFile("log.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
	defer logFile.Close()
	logger2 := &logging.Logger{
		Level: logging.DEBUG,
		StreamHandler: &logging.StreamMessageHandler{
			Level: logging.DEBUG,
			Formatter: &logging.MessageFormatter{
				Format:     `{{.Color}}[{{.Time}}] {{.LevelString | printf "%8s"}}  {{.FuncName}} {{.ShortFileName}} {{.Line}} {{.ColorClear}} {{.Message}}`,
				TimeFormat: "2006-01-02 15:04:05",
			},
			Destination: os.Stdout,
		},
		FileHandler: &logging.FileMessageHandler{
			Level: logging.ERROR,
			Formatter: &logging.MessageFormatter{
				Format: "[{{.Time}}] {{.LevelString}}  {{.Pid}} {{.Program}} {{.FuncName}} {{.LongFileName}} {{.Line}}{{.Message}}\n",
			},
			Destination: logFile,
		},
	}
	logger2.Debug("hello world")
}

Installing

---

1. using go get, go get github.com/gamelife1314/logging

2. update: go get -u github.com/gamelife1314/logging

Documentation

---

1. see http://godoc.org/github.com/gamelife1314/logging

2. or run command: godoc github.com/gamelife1314/logging

Documentation

Overview

* Package logging implements a logging infrastructure. It supports different MessageHandler like StreamHandler for console and FileHandler for file output; Every MessageHandler can have different MessageFormatter and MessageFilter.

Index

• Constants
• Variables
• type FileMessageHandler
  • func (handler FileMessageHandler) Write(message []byte)
• type Logger
  • func GetDefaultLogger() *Logger
  • func (l *Logger) Critical(format string, a ...interface{})
  • func (l *Logger) Debug(format string, a ...interface{})
  • func (l *Logger) Error(format string, a ...interface{})
  • func (l *Logger) Info(format string, a ...interface{})
  • func (l *Logger) Notice(format string, a ...interface{})
  • func (l *Logger) Warning(format string, a ...interface{})
• type MessageFilter
• type MessageFormatter
  • func (formatter *MessageFormatter) GetMessage(logger *Logger) string
• type MessageHandler
• type MessageLevel
• type MessageRecord
  • func GetMessageRecord(level MessageLevel, format string, a ...interface{}) *MessageRecord
• type StreamMessageHandler
  • func (handler StreamMessageHandler) Write(message []byte)

Constants

const (
	ColorRed     // red
	ColorGreen   // green
	ColorYellow  // yellow
	ColorBlue    // blue
	ColorMagenta // magenta

	ColorWhite // white
)

const (
	NOTSET   = iota
	DEBUG    = MessageLevel(10 * iota) // DEBUG = 10
	INFO     = MessageLevel(10 * iota) // INFO = 20
	NOTICE   = MessageLevel(10 * iota) // INFO = 30
	WARNING  = MessageLevel(10 * iota) // WARNING = 40
	ERROR    = MessageLevel(10 * iota) // ERROR = 50
	CRITICAL = MessageLevel(10 * iota) // CRITICAL = 60
)

MessageLevel

const LevelColorSeqClear = "\033[0m"

Variables

var LevelColorFlag = []string{
	DEBUG:    levelColorSeq(ColorBlue, 0),
	INFO:     levelColorSeq(ColorGreen, 0),
	NOTICE:   levelColorSeq(ColorWhite, 0),
	WARNING:  levelColorSeq(ColorYellow, 0),
	ERROR:    levelColorSeq(ColorRed, 1),
	CRITICAL: levelColorSeq(ColorMagenta, 1),
}

LevelColorFlag, MessageLevel color flag.

var LevelString = map[MessageLevel]string{
	DEBUG:    "DEBUG",
	INFO:     "INFO",
	NOTICE:   "NOTICE",
	WARNING:  "WARNING",
	ERROR:    "ERROR",
	CRITICAL: "CRITICAL",
}

LevelString, MessageLevel string.

Types

type FileMessageHandler

type FileMessageHandler struct {
	Level       MessageLevel
	Filter      MessageFilter
	Formatter   *MessageFormatter
	Destination io.Writer
}

logging.FileMessageHandler

func (FileMessageHandler) Write

func (handler FileMessageHandler) Write(message []byte)

type Logger

type Logger struct {
	Level         MessageLevel          // continue only message level gte Level
	Filter        MessageFilter         // logger message filter, you can define it as your will.
	Record        *MessageRecord        // message entity, you must not instance it.
	StreamHandler *StreamMessageHandler // StreamMessageHandler
	FileHandler   *FileMessageHandler   // FileMessageHandler
}

Logger, define logger entity.

func GetDefaultLogger

func GetDefaultLogger() *Logger

logging.GetDefaultLogger, return a default logger object.

func (*Logger) Critical

func (l *Logger) Critical(format string, a ...interface{})

Logger.Critical, record CRITICAL message.

func (*Logger) Debug

func (l *Logger) Debug(format string, a ...interface{})

Logger.Debug, record DEBUG message.

func (*Logger) Error

func (l *Logger) Error(format string, a ...interface{})

Logger.Error, record ERROR message.

func (*Logger) Info

func (l *Logger) Info(format string, a ...interface{})

Logger.Info, record INFO message.

func (*Logger) Notice

func (l *Logger) Notice(format string, a ...interface{})

Logger.Notice, record INFO message.

func (*Logger) Warning

func (l *Logger) Warning(format string, a ...interface{})

Logger.Warning, record WARNING message.

type MessageFilter

type MessageFilter func(logger *Logger) bool

logging.MessageFilter, for message filter.

type MessageFormatter

type MessageFormatter struct {

	// Message Format, you can use any fields of MessageRecord.
	// Example: {{.Color}}[{{.Time}}] {{.LevelString}}  {{.FuncName}} {{.ShortFileName}} {{.Line}} {{.ColorClear}} {{.Message}}\n
	Format string

	// Message Time Format
	// Default: time.RFC1123
	TimeFormat string
}

logging.MessageFormatter

func (*MessageFormatter) GetMessage

func (formatter *MessageFormatter) GetMessage(logger *Logger) string

logging.MessageFormatter.GetMessage, return formatted message string for output.

type MessageHandler

type MessageHandler interface {
	Write(message []byte)
}

type MessageLevel

type MessageLevel int

type MessageRecord

type MessageRecord struct {
	Level         MessageLevel
	LevelString   string
	Message       string
	Pid           int
	Program       string
	Time          string
	FuncName      string
	LongFileName  string
	ShortFileName string
	Line          int
	Color         string
	ColorClear    string
}

logging.MessageRecord

func GetMessageRecord

func GetMessageRecord(level MessageLevel, format string, a ...interface{}) *MessageRecord

logging.getMessageRecord, make a record and return it's reference.

type StreamMessageHandler

type StreamMessageHandler struct {
	Level       MessageLevel
	Filter      MessageFilter
	Formatter   *MessageFormatter
	Destination io.Writer
}

logging.StreamMessageHandler

func (StreamMessageHandler) Write

func (handler StreamMessageHandler) Write(message []byte)