271 lines
7.6 KiB
Go
271 lines
7.6 KiB
Go
// Copyright (c) 2017-2018, Stanislav N. aka pztrn.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject
|
|
// to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
|
|
// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
package mogrus
|
|
|
|
import (
|
|
// stdlib
|
|
"io"
|
|
"strings"
|
|
"sync"
|
|
|
|
// github
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type LoggerHandler struct {
|
|
// Logrus instances
|
|
instances map[string]*logrus.Logger
|
|
instancesMutex sync.Mutex
|
|
}
|
|
|
|
// CreateOutput adds output for logger handler.
|
|
// This actually creates new Logrus's Logger instance and configure
|
|
// it to write to given writer.
|
|
// To configure debug level you should pass it's name as debugLvl.
|
|
// Valid values: "", "debug" (the default), "info", "warn", "error"
|
|
func (lh *LoggerHandler) CreateOutput(name string, writer io.Writer, colors bool, debugLvl string) {
|
|
// Formatter.
|
|
logrus_formatter := new(logrus.TextFormatter)
|
|
logrus_formatter.DisableTimestamp = false
|
|
logrus_formatter.FullTimestamp = true
|
|
logrus_formatter.QuoteEmptyFields = true
|
|
logrus_formatter.TimestampFormat = "2006-01-02 15:04:05.000000000"
|
|
|
|
if colors {
|
|
logrus_formatter.DisableColors = false
|
|
logrus_formatter.ForceColors = true
|
|
} else {
|
|
logrus_formatter.DisableColors = true
|
|
logrus_formatter.ForceColors = false
|
|
}
|
|
|
|
logrus_instance := logrus.New()
|
|
logrus_instance.Out = writer
|
|
// Defaulting to debug.
|
|
logrus_instance.Level = logrus.DebugLevel
|
|
if debugLvl == "info" {
|
|
logrus_instance.Level = logrus.InfoLevel
|
|
} else if debugLvl == "warn" {
|
|
logrus_instance.Level = logrus.WarnLevel
|
|
} else if debugLvl == "error" {
|
|
logrus_instance.Level = logrus.ErrorLevel
|
|
}
|
|
logrus_instance.Formatter = logrus_formatter
|
|
|
|
lh.instancesMutex.Lock()
|
|
lh.instances[name] = logrus_instance
|
|
|
|
for _, logger := range lh.instances {
|
|
logger.Debugln("Added new logger output:", name)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// FormatString formats string by replacing "{{ var }}"'s with data from
|
|
// passed map.
|
|
func (lh *LoggerHandler) FormatString(data string, replacers map[string]string) string {
|
|
for k, v := range replacers {
|
|
data = strings.Replace(data, "{{ "+k+" }}", v, -1)
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
// Initialize initializes logger handler.
|
|
// It will only initializes LoggerHandler structure, see CreateOutput()
|
|
// for configuring output for this logger handler.
|
|
func (lh *LoggerHandler) Initialize() {
|
|
lh.instances = make(map[string]*logrus.Logger)
|
|
}
|
|
|
|
// RemoveOutput removes previously created output.
|
|
// If output isn't found - doing nothing.
|
|
func (lh *LoggerHandler) RemoveOutput(output_name string) {
|
|
lh.instancesMutex.Lock()
|
|
_, found := lh.instances[output_name]
|
|
if found {
|
|
delete(lh.instances, output_name)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Debug() function.
|
|
func (lh *LoggerHandler) Debug(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Debug(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Debugf() function.
|
|
func (lh *LoggerHandler) Debugf(format string, args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Debugf(format, args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Debugln() function.
|
|
func (lh *LoggerHandler) Debugln(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Debugln(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Error() function.
|
|
func (lh *LoggerHandler) Error(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Error(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Errorf() function.
|
|
func (lh *LoggerHandler) Errorf(format string, args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Errorf(format, args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Errorln() function.
|
|
func (lh *LoggerHandler) Errorln(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Errorln(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Fatal() function.
|
|
func (lh *LoggerHandler) Fatal(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Fatal(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Fatalf() function.
|
|
func (lh *LoggerHandler) Fatalf(format string, args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Fatalf(format, args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Fatalln() function.
|
|
func (lh *LoggerHandler) Fatalln(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Fatalln(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Info() function.
|
|
func (lh *LoggerHandler) Info(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Info(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Infof() function.
|
|
func (lh *LoggerHandler) Infof(format string, args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Infof(format, args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Infoln() function.
|
|
func (lh *LoggerHandler) Infoln(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Infoln(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Print() function.
|
|
func (lh *LoggerHandler) Print(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Print(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Printf() function.
|
|
func (lh *LoggerHandler) Printf(format string, args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Printf(format, args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Println() function.
|
|
func (lh *LoggerHandler) Println(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Println(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Warn() function.
|
|
func (lh *LoggerHandler) Warn(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Warn(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Warnf() function.
|
|
func (lh *LoggerHandler) Warnf(format string, args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Warnf(format, args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|
|
|
|
// Proxy for Logrus's Logger.Warnln() function.
|
|
func (lh *LoggerHandler) Warnln(args ...interface{}) {
|
|
lh.instancesMutex.Lock()
|
|
for _, logger := range lh.instances {
|
|
logger.Warnln(args...)
|
|
}
|
|
lh.instancesMutex.Unlock()
|
|
}
|