gol4ng/logger

package logger

import (
    "github.com/valyala/bytebufferpool"
)

// Context contain all contextual log data
// we advise you to choose your data wisely
// You should keep a reasonable quantity of data
type Context map[string]Field

// Merge and overwrite context data with the given one
func (c *Context) Merge(context Context) *Context {
    for _, field := range context {
        c.SetField(field)
    }
    return c
}

// SetField will add a new context field
func (c *Context) SetField(fields ...Field) *Context {
    for _, field := range fields {
        (*c)[field.Name] = field
    }
    return c
}

// Has will checks if the current context has a field name
func (c *Context) Has(name string) bool {
    _, ok := (*c)[name]
    return ok
}

// Get will return field with given name or the default value
func (c *Context) Get(name string, defaultField *Field) Field {
    if c.Has(name) {
        return (*c)[name]
    }
    return *defaultField
}

// Add will guess and add value to the context
func (c *Context) Add(name string, value interface{}) *Context {
    return c.SetField(Any(name, value))
}

// Skip will add skip field to context
func (c *Context) Skip(name string, value string) *Context {
    return c.SetField(Skip(name, value))
}

// Binary will add binary field to context
func (c *Context) Binary(name string, value []byte) *Context {
    return c.SetField(Binary(name, value))
}

// ByteString will add byteString field to context
func (c *Context) ByteString(name string, value []byte) *Context {
    return c.SetField(ByteString(name, value))
}

func (c *Context) StringTo(byteBuffer *bytebufferpool.ByteBuffer) *Context {
    if len(*c) == 0 {
        byteBuffer.WriteString("<nil>")
        return c
    }
    first := true
    for name, field := range *c {
        if !first {
            byteBuffer.WriteString(" ")
        }
        byteBuffer.WriteString("<")
        byteBuffer.WriteString(name)
        byteBuffer.WriteString(":")
        byteBuffer.WriteString(field.String())
        byteBuffer.WriteString(">")
        first = false
    }
    return c
}

// Slice will return fields as *Fields
func (c *Context) Slice() *Fields {
    slice := Fields{}
    for _, field := range *c {
        slice = append(slice, field)
    }
    return &slice
}

// String will return fields as string
func (c *Context) String() string {
    if c == nil || len(*c) == 0 {
        return "<nil>"
    }
    byteBuffer := bytebufferpool.Get()
    defer bytebufferpool.Put(byteBuffer)
    c.StringTo(byteBuffer)
    return byteBuffer.String()
}

// GoString was called by fmt.Printf("%#v", context)
// fmt GoStringer interface
func (c *Context) GoString() string {
    byteBuffer := bytebufferpool.Get()
    defer bytebufferpool.Put(byteBuffer)

    byteBuffer.WriteString("logger.context[")
    c.StringTo(byteBuffer)
    byteBuffer.WriteString("]")
    return byteBuffer.String()
}

// Ctx will create a new context with given value
func Ctx(name string, value interface{}) *Context {
    return NewContext().Add(name, value)
}

// NewContext will create a new context with optional fields
func NewContext(fields ...Field) *Context {
    return (&Context{}).SetField(fields...)
}