Added formatters. Fixed an issue where logrus would not set the proper level

Author: jucardi

.idea/dictionaries/jcdiaz.xml

@@ -0,0 +1,29 @@
+package log
+
+import (
+	"time"
+)
+
+// Entry represents a log entry.
+type Entry struct {
+	// Contains all the fields set by the user. TODO
+	Data map[string]interface{}
+
+	// Time at which the log entry was created
+	Timestamp time.Time
+
+	// Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
+	Level Level
+
+	// Message passed to Debug, Info, Warn, Error, Fatal or Panic
+	Message string
+
+	metadata map[string]interface{}
+}
+
+func (e *Entry) AddMetadata(key string, val interface{}) {
+	if e.metadata == nil {
+		e.metadata = map[string]interface{}{}
+	}
+	e.metadata[key] = val
+}

.idea/go-logger-lib.iml

@@ -0,0 +1,80 @@
+package log
+
+import (
+	"io"
+	"os"
+	"strings"
+	"text/template"
+)
+
+const (
+	TemplateDefault = `{{ .Level }} {{ .Timestamp }} | {{ .Message }}`
+)
+
+// The Formatter interface is used to implement a custom Formatter. It takes an
+// `Entry`. It exposes all the fields, including the default ones:
+//
+// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
+// * `entry.Data["time"]`. The timestamp.
+// * `entry.Data["level"]. The level the entry was logged at.
+//
+// Any additional fields added with `WithField` or `WithFields` are also in
+// `entry.Data`. Format is expected to return an array of bytes which are then
+// logged to `logger.Out`.
+type IFormatter interface {
+	Format(io.Writer, *Entry) error
+	SetTemplate(string) error
+}
+
+// BaseFormatter base structure for formatters
+type BaseFormatter struct {
+	templateHandler *template.Template
+	helpers         template.FuncMap
+}
+
+func (f *BaseFormatter) SetTemplate(tmpl string) error {
+	t, err := template.New("formatter").Funcs(f.helpers).Parse(tmpl)
+	if err != nil {
+		return err
+	}
+	f.templateHandler = t
+	return nil
+}
+
+// BaseTerminalFormatter base structure to create formatters for a terminal
+type BaseTerminalFormatter struct {
+	BaseFormatter
+	// Set to true to bypass checking for a TTY before outputting colors.
+	ForceColors bool
+
+	// Force disabling colors.
+	DisableColors bool
+
+	// Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
+	EnvironmentOverrideColors bool
+	supportsColor             *bool
+	colorScheme               LevelColorScheme
+}
+
+func (f *BaseTerminalFormatter) isColored() bool {
+	if f.supportsColor == nil {
+		supportsColor := f.ForceColors
+
+		if force, ok := os.LookupEnv("CLICOLOR_FORCE"); ok && force != "0" {
+			supportsColor = true
+		} else if ok && force == "0" {
+			supportsColor = false
+		} else if os.Getenv("CLICOLOR") == "0" {
+			supportsColor = false
+		} else if strings.Contains(os.Getenv("TERM"), "color") {
+			supportsColor = true
+		}
+		f.supportsColor = &supportsColor
+	}
+
+	return *f.supportsColor && !f.DisableColors
+}
+
+func (f *BaseTerminalFormatter) SetColorScheme(scheme LevelColorScheme) {
+	f.colorScheme = scheme
+}

.idea/misc.xml

@@ -0,0 +1,73 @@
+package log
+
+import (
+	"fmt"
+	"github.com/jucardi/go-iso8601"
+	"github.com/jucardi/go-streams/streams"
+	"github.com/jucardi/go-terminal-colors"
+	"strings"
+	"text/template"
+)
+
+const (
+	metadataColorEnabled = "colored"
+	metadataColorScheme  = "color_scheme"
+)
+
+func getDefaultHelpers() template.FuncMap {
+	return template.FuncMap{
+		"string":    stringFn,
+		"upper":     uppercaseFn,
+		"lower":     lowercaseFn,
+		"fmt":       formatFn,
+		"level":     coloredLevelFn,
+		"timestamp": timestampFn,
+		"colorCode": colorCodeFn,
+		"color":     colorFn,
+	}
+}
+
+func stringFn(arg interface{}) string {
+	return fmt.Sprintf("%+v", arg)
+}
+
+func uppercaseFn(arg string) string {
+	return strings.ToUpper(stringFn(arg))
+}
+
+func lowercaseFn(arg interface{}) string {
+	return strings.ToLower(stringFn(arg))
+}
+
+func formatFn(format string, args ...interface{}) string {
+	return fmt.Sprintf(format, args...)
+}
+
+func coloredLevelFn(entry Entry) string {
+	if v, ok := entry.metadata[metadataColorEnabled]; ok && !v.(bool) {
+		return entry.Level.String()
+	}
+	if _, ok := entry.metadata[metadataColorScheme]; !ok {
+		return entry.Level.String()
+	}
+
+	scheme := entry.metadata[metadataColorScheme].(LevelColorScheme)
+	colors := scheme[entry.Level]
+
+	return fmtc.New().Print(fmt.Sprintf(" %s ", strings.ToUpper(entry.Level.String())), colors...).String()
+}
+
+func timestampFn(entry Entry, format string) string {
+	return iso8601.TimeToString(entry.Timestamp, format)
+}
+
+func colorCodeFn(arg interface{}, colors ...fmtc.Color) string {
+	return fmtc.New().Print(arg, colors...).String()
+}
+
+func colorFn(arg interface{}, colors ...string) string {
+	return fmtc.New().Print(arg, streams.From(colors).Map(func(i interface{}) interface{} {
+		ret, _ := fmtc.Parse(i.(string))
+		return ret
+	}).ToArray().([]fmtc.Color)...).String()
+}

.idea/modules.xml

@@ -0,0 +1,56 @@
+package log
+
+import (
+	"errors"
+	"fmt"
+	"github.com/jucardi/go-terminal-colors"
+	"io"
+)
+
+// TextFormatter formats logs into text
+type TerminalFormatter struct {
+	BaseTerminalFormatter
+}
+
+type LevelColorScheme map[Level][]fmtc.Color
+
+const (
+	TemplateTerminalFormatter = `{{ level . }} {{ color (timestamp . "HH:mm:ss") "Cyan" }} {{ .Message }}`
+)
+
+var DefaultColorScheme = LevelColorScheme{
+	DebugLevel: []fmtc.Color{fmtc.Bold, fmtc.DarkGray},
+	InfoLevel:  []fmtc.Color{fmtc.Bold, fmtc.White, fmtc.BgBlue},
+	WarnLevel:  []fmtc.Color{fmtc.Black, fmtc.BgYellow},
+	ErrorLevel: []fmtc.Color{fmtc.Bold, fmtc.White, fmtc.BgRed},
+	FatalLevel: []fmtc.Color{fmtc.Bold, fmtc.White, fmtc.BgRed},
+	PanicLevel: []fmtc.Color{fmtc.Bold, fmtc.White, fmtc.BgRed},
+}
+
+func NewTerminalFormatter() IFormatter {
+	ret := &TerminalFormatter{}
+	ret.helpers = getDefaultHelpers()
+	ret.SetTemplate(TemplateTerminalFormatter)
+	ret.SetColorScheme(DefaultColorScheme)
+	return ret
+}
+
+// Format renders a single log entry
+func (f *TerminalFormatter) Format(writer io.Writer, entry *Entry) error {
+	if f.templateHandler == nil {
+		return errors.New("no template parser found")
+	}
+
+	if writer == nil {
+		return errors.New("writer cannot be nil")
+	}
+
+	entry.AddMetadata(metadataColorEnabled, f.isColored())
+	entry.AddMetadata(metadataColorScheme, f.colorScheme)
+	if err := f.templateHandler.Execute(writer, entry); err != nil {
+		return fmt.Errorf("unable to write log to io writer, %s", err.Error())
+	}
+
+	fmt.Fprintln(writer)
+	return nil
+}