mirror of
https://github.com/42wim/matterbridge.git
synced 2024-12-18 17:12:37 +01:00
279 lines
8.2 KiB
Go
279 lines
8.2 KiB
Go
// Copyright (C) 2010, Kyle Lemons <kyle@kylelemons.net>. All rights reserved.
|
|
|
|
package log4go
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
Global Logger
|
|
)
|
|
|
|
func init() {
|
|
Global = NewDefaultLogger(DEBUG)
|
|
}
|
|
|
|
// Wrapper for (*Logger).LoadConfiguration
|
|
func LoadConfiguration(filename string) {
|
|
Global.LoadConfiguration(filename)
|
|
}
|
|
|
|
// Wrapper for (*Logger).AddFilter
|
|
func AddFilter(name string, lvl Level, writer LogWriter) {
|
|
Global.AddFilter(name, lvl, writer)
|
|
}
|
|
|
|
// Wrapper for (*Logger).Close (closes and removes all logwriters)
|
|
func Close() {
|
|
Global.Close()
|
|
}
|
|
|
|
func Crash(args ...interface{}) {
|
|
if len(args) > 0 {
|
|
Global.intLogf(CRITICAL, strings.Repeat(" %v", len(args))[1:], args...)
|
|
}
|
|
panic(args)
|
|
}
|
|
|
|
// Logs the given message and crashes the program
|
|
func Crashf(format string, args ...interface{}) {
|
|
Global.intLogf(CRITICAL, format, args...)
|
|
Global.Close() // so that hopefully the messages get logged
|
|
panic(fmt.Sprintf(format, args...))
|
|
}
|
|
|
|
// Compatibility with `log`
|
|
func Exit(args ...interface{}) {
|
|
if len(args) > 0 {
|
|
Global.intLogf(ERROR, strings.Repeat(" %v", len(args))[1:], args...)
|
|
}
|
|
Global.Close() // so that hopefully the messages get logged
|
|
os.Exit(0)
|
|
}
|
|
|
|
// Compatibility with `log`
|
|
func Exitf(format string, args ...interface{}) {
|
|
Global.intLogf(ERROR, format, args...)
|
|
Global.Close() // so that hopefully the messages get logged
|
|
os.Exit(0)
|
|
}
|
|
|
|
// Compatibility with `log`
|
|
func Stderr(args ...interface{}) {
|
|
if len(args) > 0 {
|
|
Global.intLogf(ERROR, strings.Repeat(" %v", len(args))[1:], args...)
|
|
}
|
|
}
|
|
|
|
// Compatibility with `log`
|
|
func Stderrf(format string, args ...interface{}) {
|
|
Global.intLogf(ERROR, format, args...)
|
|
}
|
|
|
|
// Compatibility with `log`
|
|
func Stdout(args ...interface{}) {
|
|
if len(args) > 0 {
|
|
Global.intLogf(INFO, strings.Repeat(" %v", len(args))[1:], args...)
|
|
}
|
|
}
|
|
|
|
// Compatibility with `log`
|
|
func Stdoutf(format string, args ...interface{}) {
|
|
Global.intLogf(INFO, format, args...)
|
|
}
|
|
|
|
// Send a log message manually
|
|
// Wrapper for (*Logger).Log
|
|
func Log(lvl Level, source, message string) {
|
|
Global.Log(lvl, source, message)
|
|
}
|
|
|
|
// Send a formatted log message easily
|
|
// Wrapper for (*Logger).Logf
|
|
func Logf(lvl Level, format string, args ...interface{}) {
|
|
Global.intLogf(lvl, format, args...)
|
|
}
|
|
|
|
// Send a closure log message
|
|
// Wrapper for (*Logger).Logc
|
|
func Logc(lvl Level, closure func() string) {
|
|
Global.intLogc(lvl, closure)
|
|
}
|
|
|
|
// Utility for finest log messages (see Debug() for parameter explanation)
|
|
// Wrapper for (*Logger).Finest
|
|
func Finest(arg0 interface{}, args ...interface{}) {
|
|
const (
|
|
lvl = FINEST
|
|
)
|
|
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 fine log messages (see Debug() for parameter explanation)
|
|
// Wrapper for (*Logger).Fine
|
|
func Fine(arg0 interface{}, args ...interface{}) {
|
|
const (
|
|
lvl = FINE
|
|
)
|
|
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...)
|
|
}
|
|
}
|
|
|
|
// Utility for trace log messages (see Debug() for parameter explanation)
|
|
// Wrapper for (*Logger).Trace
|
|
func Trace(arg0 interface{}, args ...interface{}) {
|
|
const (
|
|
lvl = TRACE
|
|
)
|
|
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 info log messages (see Debug() for parameter explanation)
|
|
// 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 warn log messages (returns an error for easy function returns) (see Debug() for parameter explanation)
|
|
// These functions will execute a closure exactly once, to build the error message for the return
|
|
// Wrapper for (*Logger).Warn
|
|
func Warn(arg0 interface{}, args ...interface{}) error {
|
|
const (
|
|
lvl = WARNING
|
|
)
|
|
switch first := arg0.(type) {
|
|
case string:
|
|
// Use the string as a format string
|
|
Global.intLogf(lvl, first, args...)
|
|
return errors.New(fmt.Sprintf(first, args...))
|
|
case func() string:
|
|
// Log the closure (no other arguments used)
|
|
str := first()
|
|
Global.intLogf(lvl, "%s", str)
|
|
return errors.New(str)
|
|
default:
|
|
// Build a format string so that it will be similar to Sprint
|
|
Global.intLogf(lvl, fmt.Sprint(first)+strings.Repeat(" %v", len(args)), args...)
|
|
return errors.New(fmt.Sprint(first) + fmt.Sprintf(strings.Repeat(" %v", len(args)), args...))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Utility for error log messages (returns an error for easy function returns) (see Debug() for parameter explanation)
|
|
// These functions will execute a closure exactly once, to build the error message for the return
|
|
// Wrapper for (*Logger).Error
|
|
func Error(arg0 interface{}, args ...interface{}) error {
|
|
const (
|
|
lvl = ERROR
|
|
)
|
|
switch first := arg0.(type) {
|
|
case string:
|
|
// Use the string as a format string
|
|
Global.intLogf(lvl, first, args...)
|
|
return errors.New(fmt.Sprintf(first, args...))
|
|
case func() string:
|
|
// Log the closure (no other arguments used)
|
|
str := first()
|
|
Global.intLogf(lvl, "%s", str)
|
|
return errors.New(str)
|
|
default:
|
|
// Build a format string so that it will be similar to Sprint
|
|
Global.intLogf(lvl, fmt.Sprint(first)+strings.Repeat(" %v", len(args)), args...)
|
|
return errors.New(fmt.Sprint(first) + fmt.Sprintf(strings.Repeat(" %v", len(args)), args...))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Utility for critical log messages (returns an error for easy function returns) (see Debug() for parameter explanation)
|
|
// These functions will execute a closure exactly once, to build the error message for the return
|
|
// Wrapper for (*Logger).Critical
|
|
func Critical(arg0 interface{}, args ...interface{}) error {
|
|
const (
|
|
lvl = CRITICAL
|
|
)
|
|
switch first := arg0.(type) {
|
|
case string:
|
|
// Use the string as a format string
|
|
Global.intLogf(lvl, first, args...)
|
|
return errors.New(fmt.Sprintf(first, args...))
|
|
case func() string:
|
|
// Log the closure (no other arguments used)
|
|
str := first()
|
|
Global.intLogf(lvl, "%s", str)
|
|
return errors.New(str)
|
|
default:
|
|
// Build a format string so that it will be similar to Sprint
|
|
Global.intLogf(lvl, fmt.Sprint(first)+strings.Repeat(" %v", len(args)), args...)
|
|
return errors.New(fmt.Sprint(first) + fmt.Sprintf(strings.Repeat(" %v", len(args)), args...))
|
|
}
|
|
return nil
|
|
}
|