First commit
This commit is contained in:
Pavel Shevaev
commit
fa31019ff5
|
|
@ -0,0 +1,435 @@
|
||||||
|
// Package colog implements prefix based logging by setting itself as output of the standard library
|
||||||
|
// and parsing the log messages. Level prefixes are called headers in CoLog terms to not confuse with
|
||||||
|
// log.Prefix() which is independent.
|
||||||
|
// Basic usage only requires registering:
|
||||||
|
// func main() {
|
||||||
|
// colog.Register()
|
||||||
|
// log.Print("info: that's all it takes!")
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// CoLog requires the standard logger to submit messages without prefix or flags. So it resets them
|
||||||
|
// while registering and assigns them to itself, unfortunately CoLog cannot be aware of any output
|
||||||
|
// previously set.
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"log"
|
||||||
|
"os"
|
||||||
|
"runtime"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
// std is the global singleton
|
||||||
|
// analog of the standard log.std
|
||||||
|
var std = NewCoLog(os.Stderr, "", 0)
|
||||||
|
|
||||||
|
// CoLog encapsulates our log writer
|
||||||
|
type CoLog struct {
|
||||||
|
mu sync.Mutex
|
||||||
|
host string
|
||||||
|
prefix []byte
|
||||||
|
minLevel Level
|
||||||
|
defaultLevel Level
|
||||||
|
formatter Formatter
|
||||||
|
customFmt bool
|
||||||
|
out io.Writer
|
||||||
|
}
|
||||||
|
|
||||||
|
// Entry represents a message being logged and all attached data
|
||||||
|
type Entry struct {
|
||||||
|
Level Level // severity: trace, debug, info, warning, error, alert
|
||||||
|
Time time.Time // time of the event
|
||||||
|
Host string // host origin of the message
|
||||||
|
File string // file where the log was called
|
||||||
|
Line int // line in the file where the log was called
|
||||||
|
Message []byte // logged message
|
||||||
|
}
|
||||||
|
|
||||||
|
// Level represents severity level
|
||||||
|
type Level uint8
|
||||||
|
|
||||||
|
// LevelMap links levels with output header bytes
|
||||||
|
type LevelMap map[Level][]byte
|
||||||
|
|
||||||
|
// HeaderMap links input header strings with levels
|
||||||
|
type HeaderMap map[string]Level
|
||||||
|
|
||||||
|
const (
|
||||||
|
// Unknown severity level
|
||||||
|
unknown Level = iota
|
||||||
|
// LDebug represents debug severity level
|
||||||
|
LDebug
|
||||||
|
// LInfo represents info severity level
|
||||||
|
LInfo
|
||||||
|
// LWarn represents warn severity level
|
||||||
|
LWarn
|
||||||
|
// LError represents error severity level
|
||||||
|
LError
|
||||||
|
)
|
||||||
|
|
||||||
|
// String implements the Stringer interface for levels
|
||||||
|
func (level Level) String() string {
|
||||||
|
switch level {
|
||||||
|
case LDebug:
|
||||||
|
return "debug"
|
||||||
|
case LInfo:
|
||||||
|
return "info"
|
||||||
|
case LWarn:
|
||||||
|
return "warn"
|
||||||
|
case LError:
|
||||||
|
return "error"
|
||||||
|
}
|
||||||
|
|
||||||
|
return "unknown"
|
||||||
|
}
|
||||||
|
|
||||||
|
var initialMinLevel = LDebug
|
||||||
|
var initialDefaultLevel = LInfo
|
||||||
|
|
||||||
|
// NewCoLog returns CoLog instance ready to be used in logger.SetOutput()
|
||||||
|
func NewCoLog(out io.Writer, prefix string, flags int) *CoLog {
|
||||||
|
cl := new(CoLog)
|
||||||
|
cl.minLevel = initialMinLevel
|
||||||
|
cl.defaultLevel = initialDefaultLevel
|
||||||
|
cl.prefix = []byte(prefix)
|
||||||
|
cl.formatter = &StdFormatter{Flag: flags}
|
||||||
|
cl.SetOutput(out)
|
||||||
|
if host, err := os.Hostname(); err != nil {
|
||||||
|
cl.host = host
|
||||||
|
}
|
||||||
|
|
||||||
|
return cl
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Clone() *CoLog {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
item := new(CoLog)
|
||||||
|
item.minLevel = cl.minLevel
|
||||||
|
item.defaultLevel = cl.defaultLevel
|
||||||
|
item.prefix = append([]byte(nil), cl.prefix...)
|
||||||
|
item.formatter = cl.formatter
|
||||||
|
item.customFmt = cl.customFmt
|
||||||
|
item.out = cl.out
|
||||||
|
item.host = cl.host
|
||||||
|
return item
|
||||||
|
}
|
||||||
|
|
||||||
|
func Clone() *CoLog {
|
||||||
|
return std.Clone()
|
||||||
|
}
|
||||||
|
|
||||||
|
// Register sets CoLog as output for the default logger.
|
||||||
|
// It "hijacks" the standard logger flags and prefix previously set.
|
||||||
|
// It's not possible to know the output previously set, so the
|
||||||
|
// default os.Stderr is assumed.
|
||||||
|
func Register() {
|
||||||
|
// Inherit standard logger flags and prefix if appropriate
|
||||||
|
if !std.customFmt {
|
||||||
|
std.formatter.SetFlags(log.Flags())
|
||||||
|
}
|
||||||
|
|
||||||
|
if log.Prefix() != "" && len(std.prefix) == 0 {
|
||||||
|
std.SetPrefix(log.Prefix())
|
||||||
|
}
|
||||||
|
|
||||||
|
// Disable all extras
|
||||||
|
log.SetPrefix("")
|
||||||
|
log.SetFlags(0)
|
||||||
|
|
||||||
|
// Set CoLog as output
|
||||||
|
log.SetOutput(std)
|
||||||
|
}
|
||||||
|
|
||||||
|
func Get() *CoLog {
|
||||||
|
return std
|
||||||
|
}
|
||||||
|
|
||||||
|
func Set(cl *CoLog) {
|
||||||
|
std = cl
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetHost sets the logger hostname assigned to the entries
|
||||||
|
func (cl *CoLog) SetHost(host string) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.host = host
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) AddPrefix(prefix string) *CoLog {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.prefix = append(cl.prefix, []byte(prefix)...)
|
||||||
|
return cl
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) SetPrefix(prefix string) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.prefix = []byte(prefix)
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetMinLevel sets the minimum level that will be actually logged
|
||||||
|
func (cl *CoLog) SetMinLevel(l Level) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.minLevel = l
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetDefaultLevel sets the level that will be used when no level is detected
|
||||||
|
func (cl *CoLog) SetDefaultLevel(l Level) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.defaultLevel = l
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetFormatter sets the formatter to use
|
||||||
|
func (cl *CoLog) SetFormatter(f Formatter) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.customFmt = true
|
||||||
|
cl.formatter = f
|
||||||
|
}
|
||||||
|
|
||||||
|
// Flags returns the output flags for the formatter if any
|
||||||
|
func (cl *CoLog) Flags() int {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
if cl.formatter == nil {
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
|
||||||
|
return cl.formatter.Flags()
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetFlags sets the output flags for the formatter if any
|
||||||
|
func (cl *CoLog) SetFlags(flags int) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
if cl.formatter == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
cl.formatter.SetFlags(flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetOutput is analog to log.SetOutput sets the output destination.
|
||||||
|
func (cl *CoLog) SetOutput(w io.Writer) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
cl.out = w
|
||||||
|
|
||||||
|
// if we have a color formatter, notify if new output supports color
|
||||||
|
if _, ok := cl.formatter.(ColorFormatter); ok {
|
||||||
|
cl.formatter.(ColorFormatter).ColorSupported(cl.colorSupported())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewLogger returns a colog-enabled logger
|
||||||
|
func (cl *CoLog) NewLogger() *log.Logger {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
return log.New(cl, "", 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Write implements io.Writer interface to that the standard logger uses.
|
||||||
|
func (cl *CoLog) Write(p []byte) (n int, err error) {
|
||||||
|
cl.mu.Lock()
|
||||||
|
defer cl.mu.Unlock()
|
||||||
|
|
||||||
|
e := cl.makeEntry(p, LInfo, 5 /*calldepth*/)
|
||||||
|
if e.Level != unknown && e.Level < cl.minLevel {
|
||||||
|
return 0, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
if e.Level == unknown && cl.defaultLevel < cl.minLevel {
|
||||||
|
return 0, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
fp, err := cl.formatter.Format(e)
|
||||||
|
if err != nil {
|
||||||
|
fmt.Fprintf(os.Stderr, "colog: failed to format entry: %v\n", err)
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
n, err = cl.out.Write(fp)
|
||||||
|
if err != nil {
|
||||||
|
return n, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return len(p), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) makeEntry(p []byte, level Level, calldepth int) *Entry {
|
||||||
|
e := &Entry{
|
||||||
|
Time: time.Now(),
|
||||||
|
Host: cl.host,
|
||||||
|
Level: level,
|
||||||
|
Message: append(cl.prefix, bytes.TrimRight(p, "\n")...),
|
||||||
|
}
|
||||||
|
|
||||||
|
// this is a bit expensive, check is anyone might actually need it
|
||||||
|
if cl.formatter.Flags()&(log.Lshortfile|log.Llongfile) != 0 {
|
||||||
|
// release lock while getting caller info - it's expensive
|
||||||
|
// (makeEntry is called under mutex)
|
||||||
|
cl.mu.Unlock()
|
||||||
|
e.File, e.Line = getFileLine(calldepth)
|
||||||
|
cl.mu.Lock()
|
||||||
|
}
|
||||||
|
|
||||||
|
return e
|
||||||
|
}
|
||||||
|
|
||||||
|
// get file a line where logger was called
|
||||||
|
func getFileLine(calldepth int) (string, int) {
|
||||||
|
|
||||||
|
var file string
|
||||||
|
var line int
|
||||||
|
|
||||||
|
var ok bool
|
||||||
|
_, file, line, ok = runtime.Caller(calldepth)
|
||||||
|
if !ok {
|
||||||
|
file = "???"
|
||||||
|
line = 0
|
||||||
|
}
|
||||||
|
|
||||||
|
return file, line
|
||||||
|
}
|
||||||
|
|
||||||
|
// figure if output supports color
|
||||||
|
func (cl *CoLog) colorSupported() bool {
|
||||||
|
|
||||||
|
// ColorSupporters can decide themselves
|
||||||
|
if ce, ok := cl.out.(ColorSupporter); ok {
|
||||||
|
return ce.ColorSupported()
|
||||||
|
}
|
||||||
|
|
||||||
|
// Windows users need ColorSupporter outputs
|
||||||
|
if runtime.GOOS == "windows" {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check for Fd() method
|
||||||
|
output, ok := cl.out.(interface {
|
||||||
|
Fd() uintptr
|
||||||
|
})
|
||||||
|
|
||||||
|
// If no file descriptor it's not a TTY
|
||||||
|
if !ok {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
return isTerminal(int(output.Fd()))
|
||||||
|
}
|
||||||
|
|
||||||
|
/////////////////////////////////////////////////////////////////////////
|
||||||
|
func (cl *CoLog) Log(str string) {
|
||||||
|
cl.Output(LInfo, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Logf(format string, v ...interface{}) {
|
||||||
|
cl.Output(LInfo, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func Log(str string) {
|
||||||
|
std.Output(LInfo, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func Logf(format string, v ...interface{}) {
|
||||||
|
std.Output(LInfo, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Debug(str string) {
|
||||||
|
cl.Output(LDebug, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Debugf(format string, v ...interface{}) {
|
||||||
|
cl.Output(LDebug, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func Debug(str string) {
|
||||||
|
std.Output(LDebug, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func Debugf(format string, v ...interface{}) {
|
||||||
|
std.Output(LDebug, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Error(str string) {
|
||||||
|
cl.Output(LError, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Errorf(format string, v ...interface{}) {
|
||||||
|
cl.Output(LError, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func Error(str string) {
|
||||||
|
std.Output(LError, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func Errorf(format string, v ...interface{}) {
|
||||||
|
std.Output(LError, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Warn(str string) {
|
||||||
|
cl.Output(LWarn, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Warnf(format string, v ...interface{}) {
|
||||||
|
cl.Output(LWarn, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func Warn(str string) {
|
||||||
|
std.Output(LWarn, 4, str)
|
||||||
|
}
|
||||||
|
|
||||||
|
func Warnf(format string, v ...interface{}) {
|
||||||
|
std.Output(LWarn, 4, fmt.Sprintf(format, v...))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (cl *CoLog) Output(level Level, calldepth int, str string) (err error) {
|
||||||
|
//Let's do these checks before locking the mutex
|
||||||
|
if level != unknown && level < cl.minLevel {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
if level == unknown && cl.defaultLevel < cl.minLevel {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
//not using defer cl.mu.Unlock() because we want to have
|
||||||
|
//more fine grained control over mutex
|
||||||
|
cl.mu.Lock()
|
||||||
|
|
||||||
|
e := cl.makeEntry([]byte(str), level, calldepth)
|
||||||
|
|
||||||
|
fp, err := cl.formatter.Format(e)
|
||||||
|
if err != nil {
|
||||||
|
cl.mu.Unlock()
|
||||||
|
fmt.Fprintf(os.Stderr, "colog: failed to format entry: %v\n", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
out := cl.out
|
||||||
|
cl.mu.Unlock()
|
||||||
|
|
||||||
|
_, err = out.Write(fp)
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func Output(level Level, calldepth int, str string) (err error) {
|
||||||
|
return std.Output(level, calldepth, str)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,232 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"math/rand"
|
||||||
|
"sync"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
type outputTest struct {
|
||||||
|
in string
|
||||||
|
out string
|
||||||
|
}
|
||||||
|
|
||||||
|
var outputTests = []outputTest{
|
||||||
|
{"Info should be green %s", "[INF] Info should be green %s\n"},
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestColors(t *testing.T) {
|
||||||
|
|
||||||
|
log.SetFlags(log.LstdFlags)
|
||||||
|
Register()
|
||||||
|
|
||||||
|
Get().SetMinLevel(LDebug)
|
||||||
|
Get().SetDefaultLevel(LDebug)
|
||||||
|
|
||||||
|
for _, tt := range outputTests {
|
||||||
|
tt.in = fmt.Sprintf(tt.in, "")
|
||||||
|
log.Println(tt.in)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestDefaultLevel(t *testing.T) {
|
||||||
|
|
||||||
|
tw := new(mockWriter)
|
||||||
|
log.SetFlags(0)
|
||||||
|
Register()
|
||||||
|
Get().SetOutput(tw)
|
||||||
|
Get().SetFormatter(&StdFormatter{Colors: false})
|
||||||
|
Get().SetDefaultLevel(LDebug)
|
||||||
|
|
||||||
|
log.Println("no prefix text")
|
||||||
|
if "[INF] no prefix text\n" != tw.String() {
|
||||||
|
t.Fatalf("Default level failed: %s", tw.String())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestMinDefaultLevel(t *testing.T) {
|
||||||
|
|
||||||
|
tw := new(mockWriter)
|
||||||
|
log.SetFlags(0)
|
||||||
|
Register()
|
||||||
|
Get().SetOutput(tw)
|
||||||
|
Get().SetFormatter(&StdFormatter{Colors: false})
|
||||||
|
|
||||||
|
Get().SetMinLevel(LDebug)
|
||||||
|
Get().SetDefaultLevel(LDebug)
|
||||||
|
log.Println("no prefix text")
|
||||||
|
if "[INF] no prefix text\n" != tw.String() {
|
||||||
|
t.Fatalf("Default level failed: %s", tw.String())
|
||||||
|
}
|
||||||
|
|
||||||
|
Get().SetMinLevel(LError)
|
||||||
|
log.Println("should not print")
|
||||||
|
if "[INF] no prefix text\n" != tw.String() {
|
||||||
|
t.Fatalf("Default level failed: %s", tw.String())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPrefix(t *testing.T) {
|
||||||
|
|
||||||
|
tw := new(mockWriter)
|
||||||
|
cl := NewCoLog(tw, "abc ", 0)
|
||||||
|
cl.SetFormatter(&StdFormatter{Colors: false})
|
||||||
|
|
||||||
|
logger := cl.NewLogger()
|
||||||
|
logger.Println("some text")
|
||||||
|
if "[INF] abc some text\n" != tw.String() {
|
||||||
|
t.Fatalf("Prefix output failed: %s", tw.String())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSimpleOutput(t *testing.T) {
|
||||||
|
|
||||||
|
tw := new(mockWriter)
|
||||||
|
cl := NewCoLog(tw, "", 0)
|
||||||
|
cl.SetFormatter(&StdFormatter{Colors: false})
|
||||||
|
logger := cl.NewLogger()
|
||||||
|
for k, tt := range outputTests {
|
||||||
|
|
||||||
|
seq := randSeq(k)
|
||||||
|
tt.in = fmt.Sprintf(tt.in, seq)
|
||||||
|
tt.out = fmt.Sprintf(tt.out, seq)
|
||||||
|
|
||||||
|
logger.Println(tt.in)
|
||||||
|
if tt.out != tw.String() {
|
||||||
|
t.Fatalf("Simple output not found:\n %s\n %s", tt.out, string(tw.Data))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestOutputRace(t *testing.T) {
|
||||||
|
|
||||||
|
wg := sync.WaitGroup{}
|
||||||
|
wg.Add(1)
|
||||||
|
|
||||||
|
go testStdLoggerOutput(t, &wg)
|
||||||
|
for i := 0; i < 100; i++ {
|
||||||
|
wg.Add(1)
|
||||||
|
go testNewLoggerOutput(t, &wg)
|
||||||
|
}
|
||||||
|
|
||||||
|
wg.Wait()
|
||||||
|
}
|
||||||
|
|
||||||
|
func testStdLoggerOutput(t *testing.T, wg *sync.WaitGroup) {
|
||||||
|
|
||||||
|
tb := new(mockBufferWriter)
|
||||||
|
tb.Data = make(map[string][]byte, len(outputTests))
|
||||||
|
log.SetFlags(0)
|
||||||
|
Register()
|
||||||
|
Get().SetOutput(tb)
|
||||||
|
Get().SetMinLevel(LDebug)
|
||||||
|
Get().SetDefaultLevel(LDebug)
|
||||||
|
Get().SetFormatter(&StdFormatter{Colors: false})
|
||||||
|
|
||||||
|
for k, tt := range outputTests {
|
||||||
|
wg.Add(1)
|
||||||
|
go func(tt outputTest, k int) {
|
||||||
|
|
||||||
|
seq := randSeq(k)
|
||||||
|
tt.in = fmt.Sprintf(tt.in, seq)
|
||||||
|
tt.out = fmt.Sprintf(tt.out, seq)
|
||||||
|
|
||||||
|
log.Println(tt.in)
|
||||||
|
if !tb.IsWritten(tt.out) {
|
||||||
|
t.Errorf("Raced std output not found: %s", tt.out)
|
||||||
|
}
|
||||||
|
wg.Done()
|
||||||
|
}(tt, k)
|
||||||
|
}
|
||||||
|
|
||||||
|
wg.Done()
|
||||||
|
}
|
||||||
|
|
||||||
|
func testNewLoggerOutput(t *testing.T, wg *sync.WaitGroup) {
|
||||||
|
|
||||||
|
tb := new(mockBufferWriter)
|
||||||
|
tb.Data = make(map[string][]byte, len(outputTests))
|
||||||
|
cl := NewCoLog(tb, "", 0)
|
||||||
|
cl.SetFormatter(&StdFormatter{Colors: false})
|
||||||
|
logger := cl.NewLogger()
|
||||||
|
|
||||||
|
for k, tt := range outputTests {
|
||||||
|
wg.Add(1)
|
||||||
|
go func(tt outputTest, k int) {
|
||||||
|
|
||||||
|
seq := randSeq(k)
|
||||||
|
tt.in = fmt.Sprintf(tt.in, seq)
|
||||||
|
tt.out = fmt.Sprintf(tt.out, seq)
|
||||||
|
|
||||||
|
logger.Println(tt.in)
|
||||||
|
if !tb.IsWritten(tt.out) {
|
||||||
|
t.Errorf("Raced logger output not found: %s", tt.out)
|
||||||
|
}
|
||||||
|
wg.Done()
|
||||||
|
}(tt, k)
|
||||||
|
}
|
||||||
|
|
||||||
|
wg.Done()
|
||||||
|
}
|
||||||
|
|
||||||
|
type mockWriter struct {
|
||||||
|
mux sync.Mutex
|
||||||
|
Data []byte
|
||||||
|
}
|
||||||
|
|
||||||
|
func (tw *mockWriter) Write(p []byte) (n int, err error) {
|
||||||
|
tw.mux.Lock()
|
||||||
|
defer tw.mux.Unlock()
|
||||||
|
tw.Data = p
|
||||||
|
return len(p), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (tw *mockWriter) String() string {
|
||||||
|
tw.mux.Lock()
|
||||||
|
defer tw.mux.Unlock()
|
||||||
|
return string(tw.Data)
|
||||||
|
}
|
||||||
|
|
||||||
|
type mockBufferWriter struct {
|
||||||
|
mux sync.Mutex
|
||||||
|
Data map[string][]byte
|
||||||
|
}
|
||||||
|
|
||||||
|
func (tb *mockBufferWriter) Write(p []byte) (n int, err error) {
|
||||||
|
tb.mux.Lock()
|
||||||
|
defer tb.mux.Unlock()
|
||||||
|
tb.Data[string(p)] = p
|
||||||
|
return len(p), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (tb *mockBufferWriter) IsWritten(s string) bool {
|
||||||
|
tb.mux.Lock()
|
||||||
|
defer tb.mux.Unlock()
|
||||||
|
_, ok := tb.Data[s]
|
||||||
|
return ok
|
||||||
|
}
|
||||||
|
|
||||||
|
type mockHook struct {
|
||||||
|
entry *Entry
|
||||||
|
levels []Level
|
||||||
|
}
|
||||||
|
|
||||||
|
func (h *mockHook) Levels() []Level {
|
||||||
|
return h.levels
|
||||||
|
}
|
||||||
|
|
||||||
|
func (h *mockHook) Fire(e *Entry) error {
|
||||||
|
h.entry = e
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func randSeq(n int) string {
|
||||||
|
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
|
||||||
|
b := make([]rune, n)
|
||||||
|
for i := range b {
|
||||||
|
b[i] = letters[rand.Intn(len(letters))]
|
||||||
|
}
|
||||||
|
return string(b)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,35 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
// Hook is the interface to be implemented by event hooks
|
||||||
|
type Hook interface {
|
||||||
|
Levels() []Level // returns the set of levels for which the hook should be triggered
|
||||||
|
Fire(*Entry) error // triggers the hook, this function will be called for every eligible log entry
|
||||||
|
}
|
||||||
|
|
||||||
|
// Formatter interface must be implemented by message formatters
|
||||||
|
// Format(*Entry) will be called and the resulting bytes sent to output
|
||||||
|
type Formatter interface {
|
||||||
|
Format(*Entry) ([]byte, error) // The actual formatter called every time
|
||||||
|
SetFlags(flags int) // Like the standard log.SetFlags(flags int)
|
||||||
|
Flags() int // Like the standard log.Flags() int
|
||||||
|
}
|
||||||
|
|
||||||
|
// ColorFormatter interface can be implemented by formatters
|
||||||
|
// to get notifications on whether the output supports color
|
||||||
|
type ColorFormatter interface {
|
||||||
|
Formatter
|
||||||
|
ColorSupported(yes bool)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ColorSupporter interface can be implemented by "smart"
|
||||||
|
// outputs that want to handle color display themselves
|
||||||
|
type ColorSupporter interface {
|
||||||
|
ColorSupported() bool
|
||||||
|
}
|
||||||
|
|
||||||
|
// Extractor interface must be implemented by data extractors
|
||||||
|
// the extractor reads the message and tries to extract key-value
|
||||||
|
// pairs from the message and sets the in the entry
|
||||||
|
type Extractor interface {
|
||||||
|
Extract(*Entry) error
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,114 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"strconv"
|
||||||
|
)
|
||||||
|
|
||||||
|
// JSONFormatter serializes entries to JSON
|
||||||
|
// TimeFormat can be any Go time format, if empty
|
||||||
|
// it will mimic the standard logger format
|
||||||
|
// LevelAsNum will use a numeric string "1", "2",...
|
||||||
|
// for as levels instead of "trace", "debug", ..
|
||||||
|
type JSONFormatter struct {
|
||||||
|
TimeFormat string
|
||||||
|
LevelAsNum bool
|
||||||
|
Flag int
|
||||||
|
}
|
||||||
|
|
||||||
|
// JSONEntry is an entry with the final JSON field types
|
||||||
|
// We can not just implement the Marshaller interface since
|
||||||
|
// some of the process depends on runtime options
|
||||||
|
type JSONEntry struct {
|
||||||
|
Level string `json:"level,omitempty"`
|
||||||
|
Time string `json:"time,omitempty"`
|
||||||
|
Host string `json:"host,omitempty"`
|
||||||
|
File string `json:"file,omitempty"`
|
||||||
|
Line int `json:"line,omitempty"`
|
||||||
|
Message string `json:"message,omitempty"`
|
||||||
|
}
|
||||||
|
|
||||||
|
// Format takes and entry and returns the formatted output in bytes
|
||||||
|
func (jf *JSONFormatter) Format(e *Entry) ([]byte, error) {
|
||||||
|
|
||||||
|
file, line := jf.fileLine(e)
|
||||||
|
date := jf.date(e)
|
||||||
|
|
||||||
|
var level string
|
||||||
|
if jf.LevelAsNum {
|
||||||
|
level = strconv.Itoa(int(e.Level))
|
||||||
|
} else {
|
||||||
|
level = e.Level.String()
|
||||||
|
}
|
||||||
|
|
||||||
|
je := &JSONEntry{
|
||||||
|
Level: level,
|
||||||
|
Time: date,
|
||||||
|
Host: e.Host,
|
||||||
|
File: file,
|
||||||
|
Line: line,
|
||||||
|
Message: string(e.Message),
|
||||||
|
}
|
||||||
|
|
||||||
|
data, err := json.Marshal(je)
|
||||||
|
return append(data, '\n'), err
|
||||||
|
}
|
||||||
|
|
||||||
|
// Flags returns the output flags for the formatter.
|
||||||
|
func (jf *JSONFormatter) Flags() int {
|
||||||
|
return jf.Flag
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetFlags sets the output flags for the formatter.
|
||||||
|
func (jf *JSONFormatter) SetFlags(flags int) {
|
||||||
|
jf.Flag = flags
|
||||||
|
}
|
||||||
|
|
||||||
|
func (jf *JSONFormatter) fileLine(e *Entry) (file string, line int) {
|
||||||
|
if jf.Flag&(log.Lshortfile|log.Llongfile) == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
file = e.File
|
||||||
|
line = e.Line
|
||||||
|
if jf.Flag&log.Lshortfile != 0 {
|
||||||
|
short := file
|
||||||
|
for i := len(file) - 1; i > 0; i-- {
|
||||||
|
if file[i] == '/' {
|
||||||
|
short = file[i+1:]
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
file = short
|
||||||
|
}
|
||||||
|
|
||||||
|
return file, line
|
||||||
|
}
|
||||||
|
|
||||||
|
func (jf *JSONFormatter) date(e *Entry) (date string) {
|
||||||
|
if jf.TimeFormat != "" {
|
||||||
|
return e.Time.Format(jf.TimeFormat)
|
||||||
|
}
|
||||||
|
|
||||||
|
if jf.Flag&(log.Ldate|log.Ltime|log.Lmicroseconds) == 0 {
|
||||||
|
return ""
|
||||||
|
}
|
||||||
|
|
||||||
|
if jf.Flag&log.Ldate != 0 {
|
||||||
|
year, month, day := e.Time.Date()
|
||||||
|
date = fmt.Sprintf("%d/%d/%d", year, month, day)
|
||||||
|
}
|
||||||
|
|
||||||
|
if jf.Flag&(log.Ltime|log.Lmicroseconds) != 0 {
|
||||||
|
hour, min, sec := e.Time.Clock()
|
||||||
|
date = fmt.Sprintf("%s %d:%d:%d", date, hour, min, sec)
|
||||||
|
if jf.Flag&log.Lmicroseconds != 0 {
|
||||||
|
date = fmt.Sprintf("%s.%d", date, e.Time.Nanosecond())
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return date
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,74 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"log"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
type JSONFormatTest struct {
|
||||||
|
entry Entry
|
||||||
|
prefix string
|
||||||
|
flags int
|
||||||
|
tfmt string
|
||||||
|
lnum bool
|
||||||
|
output string
|
||||||
|
}
|
||||||
|
|
||||||
|
var JSONFormatTests = []JSONFormatTest{
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Level: LInfo,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
output: `{"level":"info","message":"some message"}` + "\n",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LDebug,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
flags: log.Ldate,
|
||||||
|
output: `{"level":"debug","time":"2015/8/1","message":"some message"}` + "\n",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LError,
|
||||||
|
File: "/src/file.go",
|
||||||
|
Line: 142,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
flags: log.Ldate | log.Llongfile,
|
||||||
|
output: `{"level":"error","time":"2015/8/1","file":"/src/file.go","line":142,"message":"some message"}` + "\n",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LDebug,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
lnum: true,
|
||||||
|
flags: log.Ldate,
|
||||||
|
output: `{"level":"1","time":"2015/8/1","message":"some message"}` + "\n",
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestJSONFormatter(t *testing.T) {
|
||||||
|
for _, tt := range JSONFormatTests {
|
||||||
|
f := JSONFormatter{
|
||||||
|
Flag: tt.flags,
|
||||||
|
LevelAsNum: tt.lnum,
|
||||||
|
TimeFormat: tt.tfmt,
|
||||||
|
}
|
||||||
|
|
||||||
|
b, err := f.Format(&tt.entry)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if string(b) != tt.output {
|
||||||
|
t.Errorf("Unexpected JSON formatter output: %s", b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,143 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"path/filepath"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
var colorLabels = LevelMap{
|
||||||
|
LDebug: []byte("[\x1b[0;36mDBG\x1b[0m] "),
|
||||||
|
LInfo: []byte("[\x1b[0;32mINF\x1b[0m] "),
|
||||||
|
LWarn: []byte("\x1b[0;35m[WARN]\x1b[0m "),
|
||||||
|
LError: []byte("\x1b[0;31m[ERR]\x1b[0m "),
|
||||||
|
}
|
||||||
|
|
||||||
|
var plainLabels = LevelMap{
|
||||||
|
LDebug: []byte("[DBG] "),
|
||||||
|
LInfo: []byte("[INF] "),
|
||||||
|
LWarn: []byte("[WARN] "),
|
||||||
|
LError: []byte("[ERR] "),
|
||||||
|
}
|
||||||
|
|
||||||
|
// StdFormatter supports plain and color level headers
|
||||||
|
// and bold/padded fields
|
||||||
|
type StdFormatter struct {
|
||||||
|
Flag int
|
||||||
|
Colors bool // Force enable colors
|
||||||
|
NoColors bool // Force disable colors (has preference)
|
||||||
|
colorSupported bool
|
||||||
|
}
|
||||||
|
|
||||||
|
// Format takes and entry and returns the formatted output in bytes
|
||||||
|
func (sf *StdFormatter) Format(e *Entry) ([]byte, error) {
|
||||||
|
|
||||||
|
// Normal headers. time, file, etc
|
||||||
|
var header, message []byte
|
||||||
|
sf.stdHeader(&header, e.Time, e.File, e.Line)
|
||||||
|
|
||||||
|
// Level headers
|
||||||
|
headers := sf.levelHeaders()
|
||||||
|
message = append(headers[e.Level], append(header, e.Message...)...)
|
||||||
|
|
||||||
|
return append(message, '\n'), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// levelHeaders returns plain or color level headers
|
||||||
|
// depending on user preference and output support
|
||||||
|
func (sf *StdFormatter) levelHeaders() LevelMap {
|
||||||
|
switch {
|
||||||
|
case sf.NoColors:
|
||||||
|
return plainLabels
|
||||||
|
case sf.Colors:
|
||||||
|
return colorLabels
|
||||||
|
case sf.colorSupported:
|
||||||
|
return colorLabels
|
||||||
|
}
|
||||||
|
return plainLabels
|
||||||
|
}
|
||||||
|
|
||||||
|
// Flags returns the output flags for the formatter.
|
||||||
|
func (sf *StdFormatter) Flags() int {
|
||||||
|
return sf.Flag
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetFlags sets the output flags for the formatter.
|
||||||
|
func (sf *StdFormatter) SetFlags(flags int) {
|
||||||
|
sf.Flag = flags
|
||||||
|
}
|
||||||
|
|
||||||
|
// ColorSupported enables or disables the colors, this will be called on every
|
||||||
|
func (sf *StdFormatter) ColorSupported(supp bool) {
|
||||||
|
sf.Colors = supp
|
||||||
|
}
|
||||||
|
|
||||||
|
// Adapted replica of log.Logger.formatHeader
|
||||||
|
func (sf *StdFormatter) stdHeader(buf *[]byte, t time.Time, file string, line int) {
|
||||||
|
if sf.Flag&(log.Ldate|log.Ltime|log.Lmicroseconds) != 0 {
|
||||||
|
if sf.Flag&log.Ldate != 0 {
|
||||||
|
year, month, day := t.Date()
|
||||||
|
itoa(buf, year, 4)
|
||||||
|
*buf = append(*buf, '/')
|
||||||
|
itoa(buf, int(month), 2)
|
||||||
|
*buf = append(*buf, '/')
|
||||||
|
itoa(buf, day, 2)
|
||||||
|
*buf = append(*buf, ' ')
|
||||||
|
}
|
||||||
|
if sf.Flag&(log.Ltime|log.Lmicroseconds) != 0 {
|
||||||
|
hour, min, sec := t.Clock()
|
||||||
|
itoa(buf, hour, 2)
|
||||||
|
*buf = append(*buf, ':')
|
||||||
|
itoa(buf, min, 2)
|
||||||
|
*buf = append(*buf, ':')
|
||||||
|
itoa(buf, sec, 2)
|
||||||
|
if sf.Flag&log.Lmicroseconds != 0 {
|
||||||
|
*buf = append(*buf, '.')
|
||||||
|
itoa(buf, t.Nanosecond()/1e3, 6)
|
||||||
|
}
|
||||||
|
*buf = append(*buf, ' ')
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if sf.Flag&(log.Lshortfile|log.Llongfile) != 0 {
|
||||||
|
if sf.Flag&log.Lshortfile != 0 {
|
||||||
|
short := file
|
||||||
|
for i := len(file) - 1; i > 0; i-- {
|
||||||
|
if file[i] == '/' {
|
||||||
|
short = file[i+1:]
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
file = short
|
||||||
|
} else {
|
||||||
|
file = filepath.Base(filepath.Dir(file)) + "/" + filepath.Base(file)
|
||||||
|
}
|
||||||
|
|
||||||
|
if sf.Colors {
|
||||||
|
file = fmt.Sprintf("\x1b[1;30m%s:%d:\x1b[0m ", file, line)
|
||||||
|
} else {
|
||||||
|
file = fmt.Sprintf("%s:%d: ", file, line)
|
||||||
|
}
|
||||||
|
|
||||||
|
*buf = append(*buf, file...)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Replica of log.Logger.itoa
|
||||||
|
func itoa(buf *[]byte, i int, wid int) {
|
||||||
|
var u = uint(i)
|
||||||
|
if u == 0 && wid <= 1 {
|
||||||
|
*buf = append(*buf, '0')
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Assemble decimal in reverse order.
|
||||||
|
var b [32]byte
|
||||||
|
bp := len(b)
|
||||||
|
for ; u > 0 || wid > 0; u /= 10 {
|
||||||
|
bp--
|
||||||
|
wid--
|
||||||
|
b[bp] = byte(u%10) + '0'
|
||||||
|
}
|
||||||
|
*buf = append(*buf, b[bp:]...)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,101 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"log"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
type formatTest struct {
|
||||||
|
entry Entry
|
||||||
|
prefix string
|
||||||
|
flags int
|
||||||
|
width int
|
||||||
|
colors bool
|
||||||
|
output string
|
||||||
|
}
|
||||||
|
|
||||||
|
// TTime is the fixed point in time for all formatting tests
|
||||||
|
var TTime = time.Date(2015, time.August, 1, 20, 45, 30, 9999, time.UTC)
|
||||||
|
|
||||||
|
var formatterTests = []formatTest{
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Level: LInfo,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
output: "[INF] some message\n",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LDebug,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
flags: log.Ldate,
|
||||||
|
output: "[DBG] 2015/08/01 some message\n",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LDebug,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
colors: true,
|
||||||
|
width: 40,
|
||||||
|
flags: log.Ldate,
|
||||||
|
output: "[\x1b[0;36mDBG\x1b[0m] 2015/08/01 some message\n",
|
||||||
|
},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LDebug,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
colors: true,
|
||||||
|
width: 140,
|
||||||
|
flags: log.Ldate,
|
||||||
|
output: "[\x1b[0;36mDBG\x1b[0m] 2015/08/01 some message\n"},
|
||||||
|
{
|
||||||
|
entry: Entry{
|
||||||
|
Time: TTime,
|
||||||
|
Level: LDebug,
|
||||||
|
File: "/src/file.go",
|
||||||
|
Line: 142,
|
||||||
|
Message: []byte("some message"),
|
||||||
|
},
|
||||||
|
colors: true,
|
||||||
|
width: 140,
|
||||||
|
flags: log.Llongfile,
|
||||||
|
output: "[\x1b[0;36mDBG\x1b[0m] \x1b[1;30msrc/file.go:142:\x1b[0m some message\n",
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestStdFormatter(t *testing.T) {
|
||||||
|
for _, tt := range formatterTests {
|
||||||
|
f := StdFormatter{
|
||||||
|
Flag: tt.flags,
|
||||||
|
Colors: tt.colors,
|
||||||
|
}
|
||||||
|
|
||||||
|
if tt.width > 0 {
|
||||||
|
terminalWidth = fixedWidthTerminal(tt.width)
|
||||||
|
}
|
||||||
|
|
||||||
|
b, err := f.Format(&tt.entry)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if string(b) != tt.output {
|
||||||
|
t.Errorf("Unexpected formatter output:\n%s\nVS\n%s", b, tt.output)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// stub for terminal width function
|
||||||
|
func fixedWidthTerminal(width int) func(int) int {
|
||||||
|
return func(fd int) int {
|
||||||
|
return width
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,31 @@
|
||||||
|
// +build !windows
|
||||||
|
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"syscall"
|
||||||
|
"unsafe"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Use variable indirection for test stubbing
|
||||||
|
var isTerminal = isTerminalFunc
|
||||||
|
var terminalWidth = terminalWidthFunc
|
||||||
|
|
||||||
|
// isTerminalFunc returns true if the given file descriptor is a terminal.
|
||||||
|
func isTerminalFunc(fd int) bool {
|
||||||
|
var termios syscall.Termios
|
||||||
|
_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
|
||||||
|
return err == 0
|
||||||
|
}
|
||||||
|
|
||||||
|
// terminalWidthFunc returns the width in characters of the terminal.
|
||||||
|
func terminalWidthFunc(fd int) (width int) {
|
||||||
|
var dimensions [4]uint16
|
||||||
|
|
||||||
|
_, _, errno := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&dimensions)), 0, 0, 0)
|
||||||
|
if errno != 0 {
|
||||||
|
return -1
|
||||||
|
}
|
||||||
|
|
||||||
|
return int(dimensions[1])
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,7 @@
|
||||||
|
// +build darwin dragonfly freebsd netbsd openbsd
|
||||||
|
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import "syscall"
|
||||||
|
|
||||||
|
const ioctlReadTermios = syscall.TIOCGETA
|
||||||
|
|
@ -0,0 +1,5 @@
|
||||||
|
// +build linux
|
||||||
|
|
||||||
|
package colog
|
||||||
|
|
||||||
|
const ioctlReadTermios = 0x5401
|
||||||
|
|
@ -0,0 +1,62 @@
|
||||||
|
package colog
|
||||||
|
|
||||||
|
import (
|
||||||
|
"syscall"
|
||||||
|
"unsafe"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Use variable indirection for test stubbing
|
||||||
|
var isTerminal = isTerminalFunc
|
||||||
|
var terminalWidth = terminalWidthFunc
|
||||||
|
|
||||||
|
var kernel32 = syscall.NewLazyDLL("kernel32.dll")
|
||||||
|
var procInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
|
||||||
|
var procMode = kernel32.NewProc("GetConsoleMode")
|
||||||
|
|
||||||
|
// Not applicable in windows
|
||||||
|
// define constant to avoid compilation error
|
||||||
|
const ioctlReadTermios = 0x0
|
||||||
|
|
||||||
|
// isTerminalFunc returns true if the given file descriptor is a terminal.
|
||||||
|
func isTerminalFunc(fd int) bool {
|
||||||
|
var st uint32
|
||||||
|
r, _, errno := syscall.Syscall(procMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
|
||||||
|
if errno != 0 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
return r != 0
|
||||||
|
}
|
||||||
|
|
||||||
|
type short int16
|
||||||
|
type word uint16
|
||||||
|
|
||||||
|
type coord struct {
|
||||||
|
x short
|
||||||
|
y short
|
||||||
|
}
|
||||||
|
type rectangle struct {
|
||||||
|
left short
|
||||||
|
top short
|
||||||
|
right short
|
||||||
|
bottom short
|
||||||
|
}
|
||||||
|
|
||||||
|
type termInfo struct {
|
||||||
|
size coord
|
||||||
|
cursorPosition coord
|
||||||
|
attributes word
|
||||||
|
window rectangle
|
||||||
|
maximumWindowSize coord
|
||||||
|
}
|
||||||
|
|
||||||
|
// terminalWidthFunc returns the width in characters of the terminal.
|
||||||
|
func terminalWidthFunc(fd int) (width int) {
|
||||||
|
var info termInfo
|
||||||
|
_, _, errno := syscall.Syscall(procInfo.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&info)), 0)
|
||||||
|
if errno != 0 {
|
||||||
|
return -1
|
||||||
|
}
|
||||||
|
|
||||||
|
return int(info.size.x)
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue