log4go源码分析(一)

func (c *ConsoleLogWriter) run(out io.Writer) {
  for rec := range c.w {
    fmt.Fprint(out, FormatLogRecord(c.format, rec))
  }
}
// This creates a new ConsoleLogWriter
func NewConsoleLogWriter() *ConsoleLogWriter {
  consoleWriter := &ConsoleLogWriter{
    format: "[%T %D] [%C] [%L] (%S) %M",
    w:      make(chan *LogRecord, LogBufferLength),
  }
  go consoleWriter.run(stdout)
  return consoleWriter
}

/****** LogWriter ******/
// This is an interface for anything that should be able to write logs
type LogWriter interface {
  // This will be called to log a LogRecord message.
  LogWrite(rec *LogRecord)
  // This should clean up anything lingering about the LogWriter, as it is called before
  // the LogWriter is removed.  LogWrite should not be called after Close.
  Close()
}
// This is the ConsoleLogWriter's output method.  This will block if the output
// buffer is full.
func (c *ConsoleLogWriter) LogWrite(rec *LogRecord) {
  c.w <- rec
}
// Close stops the logger from sending messages to standard output.  Attempts to
// send log messages to this logger after a Close have undefined behavior.
func (c *ConsoleLogWriter) Close() {
  close(c.w)
  time.Sleep(50 * time.Millisecond) // Try to give console I/O time to complete
}

/****** Logger ******/
// A Filter represents the log level below which no log records are written to
// the associated LogWriter.
type Filter struct {
  Level Level
  LogWriter
  Category string
}
// A Logger represents a collection of Filters through which log messages are
// written.
type Logger map[string]*Filter
// Create a new logger with a "stdout" filter configured to send log messages at
// or above lvl to standard output.
func NewDefaultLogger(lvl Level) Logger {
  return Logger{
    "stdout": &Filter{lvl, NewConsoleLogWriter(), "DEFAULT"},
  }
}

/******* Logging *******/
// Send a formatted log message internally
func (log Logger) intLogf(lvl Level, format string, args ...interface{}) {
  skip := true
  // Determine if any logging will be done
  for _, filt := range log {
    if lvl >= filt.Level {
      skip = false
      break
    }
  }
  if skip {
    return
  }
  // Determine caller func
  pc, _, lineno, ok := runtime.Caller(2)
  src := ""
  if ok {
    src = fmt.Sprintf("%s:%d", runtime.FuncForPC(pc).Name(), lineno)
  }
  msg := format
  if len(args) > 0 {
    msg = fmt.Sprintf(format, args...)
  }
  // Make the log record
  rec := &LogRecord{
    Level:   lvl,
    Created: time.Now(),
    Source:  src,
    Message: msg,
  }
  // Dispatch the logs
  for _, filt := range log {
    if lvl < filt.Level {
      continue
    }
    filt.LogWrite(rec)
  }
}

// Wrapper for (*Logger).Info
func Info(arg0 interface{}, args ...interface{}) {
  const (
    lvl = INFO
  )
  switch first := arg0.(type) {
  case string:
    // Use the string as a format string
    Global.intLogf(lvl, first, args...)
  case func() string:
    // Log the closure (no other arguments used)
    Global.intLogc(lvl, first)
  default:
    // Build a format string so that it will be similar to Sprint
    Global.intLogf(lvl, fmt.Sprint(arg0)+strings.Repeat(" %v", len(args)), args...)
  }
}

package main
import (
  "bytes"
  "fmt"
  "io"
  "os"
  "regexp"
  "runtime"
  "strings"
  "time"
)
/****** Constants ******/
// These are the integer logging levels used by the logger
type Level int
const (
  FINEST Level = iota
  FINE
  DEBUG
  TRACE
  INFO
  WARNING
  ERROR
  CRITICAL
)
// Logging level strings
var (
  levelStrings = [...]string{"FNST", "FINE", "DEBG", "TRAC", "INFO", "WARN", "EROR", "CRIT"}
)
/****** Variables ******/
var (
  // LogBufferLength specifies how many log messages a particular log4go
  // logger can buffer at a time before writing them.
  LogBufferLength = 1
)
/****** LogRecord ******/
// A LogRecord contains all of the pertinent information for each message
type LogRecord struct {
  Level    Level     // The log level
  Created  time.Time // The time at which the log message was created (nanoseconds)
  Source   string    // The message source
  Message  string    // The log message
  Category string    // The log group
}
/****** LogWriter ******/
// This is an interface for anything that should be able to write logs
type LogWriter interface {
  // This will be called to log a LogRecord message.
  LogWrite(rec *LogRecord)
  // This should clean up anything lingering about the LogWriter, as it is called before
  // the LogWriter is removed.  LogWrite should not be called after Close.
  Close()
}
/****** Logger ******/
// A Filter represents the log level below which no log records are written to
// the associated LogWriter.
type Filter struct {
  Level Level
  LogWriter
  Category string
}
// A Logger represents a collection of Filters through which log messages are
// written.
type Logger map[string]*Filter
// This is the standard writer that prints to standard output.
type ConsoleLogWriter struct {
  format string
  w      chan *LogRecord
}
var stdout io.Writer = os.Stdout
// This creates a new ConsoleLogWriter
func NewConsoleLogWriter() *ConsoleLogWriter {
  consoleWriter := &ConsoleLogWriter{
    format: "[%T %D] [%C] [%L] (%S) %M",
    w:      make(chan *LogRecord, LogBufferLength),
  }
  go consoleWriter.run(stdout)
  return consoleWriter
}
func (c *ConsoleLogWriter) SetFormat(format string) {
  c.format = format
}
func (c *ConsoleLogWriter) run(out io.Writer) {
  for rec := range c.w {
    fmt.Fprint(out, FormatLogRecord(c.format, rec))
  }
}
// This is the ConsoleLogWriter's output method.  This will block if the output
// buffer is full.
func (c *ConsoleLogWriter) LogWrite(rec *LogRecord) {
  c.w <- rec
}
// Close stops the logger from sending messages to standard output.  Attempts to
// send log messages to this logger after a Close have undefined behavior.
func (c *ConsoleLogWriter) Close() {
  close(c.w)
  time.Sleep(50 * time.Millisecond) // Try to give console I/O time to complete
}
// Create a new logger with a "stdout" filter configured to send log messages at
// or above lvl to standard output.
func NewDefaultLogger(lvl Level) Logger {
  return Logger{
    "stdout": &Filter{lvl, NewConsoleLogWriter(), "DEFAULT"},
  }
}
//
func changeDttmFormat(format string, rec *LogRecord) []byte {
  formatByte := []byte(format)
  r := regexp.MustCompile("\\%D\\{(.*?)\\}")
  i := 0
  formatByte = r.ReplaceAllFunc(formatByte, func(s []byte) []byte {
    if i < 2 {
      i++
      str := string(s)
      str = strings.Replace(str, "%D", "", -1)
      str = strings.Replace(str, "{", "", -1)
      str = strings.Replace(str, "}", "", -1)
      return []byte(rec.Created.Format(str))
    }
    return s
  })
  return formatByte
}
type formatCacheType struct {
  LastUpdateSeconds    int64
  shortTime, shortDate string
  longTime, longDate   string
}
var formatCache = &formatCacheType{}
// Known format codes:
// %T - Time (15:04:05 MST)
// %t - Time (15:04)
// %D - Date (2006/01/02)
// %d - Date (01/02/06)
// %L - Level (FNST, FINE, DEBG, TRAC, WARN, EROR, CRIT)
// %S - Source
// %M - Message
// Ignores unknown formats
// Recommended: "[%D %T] [%L] (%S) %M"
func FormatLogRecord(format string, rec *LogRecord) string {
  if rec == nil {
    return "<nil>"
  }
  if len(format) == 0 {
    return ""
  }
  out := bytes.NewBuffer(make([]byte, 0, 64))
  secs := rec.Created.UnixNano() / 1e9
  cache := *formatCache
  if cache.LastUpdateSeconds != secs {
    month, day, year := rec.Created.Month(), rec.Created.Day(), rec.Created.Year()
    hour, minute, second := rec.Created.Hour(), rec.Created.Minute(), rec.Created.Second()
    zone, _ := rec.Created.Zone()
    updated := &formatCacheType{
      LastUpdateSeconds: secs,
      shortTime:         fmt.Sprintf("%02d:%02d", hour, minute),
      shortDate:         fmt.Sprintf("%02d/%02d/%02d", day, month, year%100),
      longTime:          fmt.Sprintf("%02d:%02d:%02d %s", hour, minute, second, zone),
      longDate:          fmt.Sprintf("%04d/%02d/%02d", year, month, day),
    }
    cache = *updated
    formatCache = updated
  }
  //custom format datetime pattern %D{2006-01-02T15:04:05}
  formatByte := changeDttmFormat(format, rec)
  // Split the string into pieces by % signs
  pieces := bytes.Split(formatByte, []byte{'%'})
  // Iterate over the pieces, replacing known formats
  for i, piece := range pieces {
    if i > 0 && len(piece) > 0 {
      switch piece[0] {
      case 'T':
        out.WriteString(cache.longTime)
      case 't':
        out.WriteString(cache.shortTime)
      case 'D':
        out.WriteString(cache.longDate)
      case 'd':
        out.WriteString(cache.shortDate)
      case 'L':
        out.WriteString(levelStrings[rec.Level])
      case 'S':
        out.WriteString(rec.Source)
      case 's':
        slice := strings.Split(rec.Source, "/")
        out.WriteString(slice[len(slice)-1])
      case 'M':
        out.WriteString(rec.Message)
      case 'C':
        // if len(rec.Category) == 0 {
        //  rec.Category = "DEFAULT"
        // }
        // out.WriteString(rec.Category)
        if len(rec.Category) == 0 {
          out.WriteString("DEFAULT")
        } else {
          out.WriteString(rec.Category)
        }
      }
      if len(piece) > 1 {
        out.Write(piece[1:])
      }
    } else if len(piece) > 0 {
      out.Write(piece)
    }
  }
  out.WriteByte('\n')
  return out.String()
}
var (
  Global Logger
)
/******* Logging *******/
// Send a formatted log message internally
func (log Logger) intLogf(lvl Level, format string, args ...interface{}) {
  skip := true
  // Determine if any logging will be done
  for _, filt := range log {
    if lvl >= filt.Level {
      skip = false
      break
    }
  }
  if skip {
    return
  }
  // Determine caller func
  pc, _, lineno, ok := runtime.Caller(2)
  src := ""
  if ok {
    src = fmt.Sprintf("%s:%d", runtime.FuncForPC(pc).Name(), lineno)
  }
  msg := format
  if len(args) > 0 {
    msg = fmt.Sprintf(format, args...)
  }
  // Make the log record
  rec := &LogRecord{
    Level:   lvl,
    Created: time.Now(),
    Source:  src,
    Message: msg,
  }
  // Dispatch the logs
  for _, filt := range log {
    if lvl < filt.Level {
      continue
    }
    filt.LogWrite(rec)
  }
}
// Send a closure log message internally
func (log Logger) intLogc(lvl Level, closure func() string) {
  skip := true
  // Determine if any logging will be done
  for _, filt := range log {
    if lvl >= filt.Level {
      skip = false
      break
    }
  }
  if skip {
    return
  }
  // Determine caller func
  pc, _, lineno, ok := runtime.Caller(2)
  src := ""
  if ok {
    src = fmt.Sprintf("%s:%d", runtime.FuncForPC(pc).Name(), lineno)
  }
  // Make the log record
  rec := &LogRecord{
    Level:   lvl,
    Created: time.Now(),
    Source:  src,
    Message: closure(),
  }
  // Dispatch the logs
  for _, filt := range log {
    if lvl < filt.Level {
      continue
    }
    filt.LogWrite(rec)
  }
}
// Wrapper for (*Logger).Info
func Info(arg0 interface{}, args ...interface{}) {
  const (
    lvl = INFO
  )
  switch first := arg0.(type) {
  case string:
    // Use the string as a format string
    Global.intLogf(lvl, first, args...)
  case func() string:
    // Log the closure (no other arguments used)
    Global.intLogc(lvl, first)
  default:
    // Build a format string so that it will be similar to Sprint
    Global.intLogf(lvl, fmt.Sprint(arg0)+strings.Repeat(" %v", len(args)), args...)
  }
}
// Utility for debug log messages
// When given a string as the first argument, this behaves like Logf but with the DEBUG log level (e.g. the first argument is interpreted as a format for the latter arguments)
// When given a closure of type func()string, this logs the string returned by the closure iff it will be logged.  The closure runs at most one time.
// When given anything else, the log message will be each of the arguments formatted with %v and separated by spaces (ala Sprint).
// Wrapper for (*Logger).Debug
func Debug(arg0 interface{}, args ...interface{}) {
  const (
    lvl = DEBUG
  )
  switch first := arg0.(type) {
  case string:
    // Use the string as a format string
    Global.intLogf(lvl, first, args...)
  case func() string:
    // Log the closure (no other arguments used)
    Global.intLogc(lvl, first)
  default:
    // Build a format string so that it will be similar to Sprint
    Global.intLogf(lvl, fmt.Sprint(arg0)+strings.Repeat(" %v", len(args)), args...)
  }
}
func main() {
  Global = NewDefaultLogger(FINE)
  // original log4go test
  Info("nomal info test 1...")
  Debug("nomal debug test 1...")
  Info("nomal info test2 ...")
  Debug("nomal debug test2 ...")
  Info("nomal info test 3...")
  Debug("nomal debug test3 ...")
  Info("nomal info test4 ...")
  Debug("nomal debug test4 ...")
  Info("nomal info test 5...")
  Debug("nomal debug test ...")
  fmt.Println("over,press any key to exit ")
  name := ""
  fmt.Scanln(&name)
}