matrix-prometheus/vendor/maunium.net/go/maulogger/v2/logger.go

225 lines
6.0 KiB
Go
Raw Normal View History

2023-01-13 21:24:39 +01:00
// mauLogger - A logger for Go programs
// Copyright (c) 2016-2021 Tulir Asokan
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
package maulogger
import (
"encoding/json"
"fmt"
"io"
"os"
"strings"
"sync"
"time"
)
// LoggerFileFormat ...
type LoggerFileFormat func(now string, i int) string
type BasicLogger struct {
PrintLevel int
FlushLineThreshold int
FileTimeFormat string
FileFormat LoggerFileFormat
TimeFormat string
FileMode os.FileMode
DefaultSub Logger
JSONFile bool
JSONStdout bool
stdoutEncoder *json.Encoder
fileEncoder *json.Encoder
writer *os.File
writerLock sync.Mutex
StdoutLock sync.Mutex
StderrLock sync.Mutex
lines int
metadata map[string]interface{}
}
// Logger contains advanced logging functions
type Logger interface {
Sub(module string) Logger
Subm(module string, metadata map[string]interface{}) Logger
WithDefaultLevel(level Level) Logger
GetParent() Logger
Writer(level Level) io.WriteCloser
Log(level Level, parts ...interface{})
Logln(level Level, parts ...interface{})
Logf(level Level, message string, args ...interface{})
Logfln(level Level, message string, args ...interface{})
Debug(parts ...interface{})
Debugln(parts ...interface{})
Debugf(message string, args ...interface{})
Debugfln(message string, args ...interface{})
Info(parts ...interface{})
Infoln(parts ...interface{})
Infof(message string, args ...interface{})
Infofln(message string, args ...interface{})
Warn(parts ...interface{})
Warnln(parts ...interface{})
Warnf(message string, args ...interface{})
Warnfln(message string, args ...interface{})
Error(parts ...interface{})
Errorln(parts ...interface{})
Errorf(message string, args ...interface{})
Errorfln(message string, args ...interface{})
Fatal(parts ...interface{})
Fatalln(parts ...interface{})
Fatalf(message string, args ...interface{})
Fatalfln(message string, args ...interface{})
}
// Create a Logger
func Createm(metadata map[string]interface{}) Logger {
var log = &BasicLogger{
PrintLevel: 10,
FileTimeFormat: "2006-01-02",
FileFormat: func(now string, i int) string { return fmt.Sprintf("%[1]s-%02[2]d.log", now, i) },
TimeFormat: "15:04:05 02.01.2006",
FileMode: 0600,
FlushLineThreshold: 5,
lines: 0,
metadata: metadata,
}
log.DefaultSub = log.Sub("")
return log
}
func Create() Logger {
return Createm(map[string]interface{}{})
}
func (log *BasicLogger) EnableJSONStdout() {
log.JSONStdout = true
log.stdoutEncoder = json.NewEncoder(os.Stdout)
}
func (log *BasicLogger) GetParent() Logger {
return nil
}
// SetWriter formats the given parts with fmt.Sprint and logs the result with the SetWriter level
func (log *BasicLogger) SetWriter(w *os.File) {
log.writer = w
if log.JSONFile {
log.fileEncoder = json.NewEncoder(w)
}
}
// OpenFile formats the given parts with fmt.Sprint and logs the result with the OpenFile level
func (log *BasicLogger) OpenFile() error {
now := time.Now().Format(log.FileTimeFormat)
i := 1
for ; ; i++ {
if _, err := os.Stat(log.FileFormat(now, i)); os.IsNotExist(err) {
break
}
}
writer, err := os.OpenFile(log.FileFormat(now, i), os.O_WRONLY|os.O_CREATE|os.O_APPEND, log.FileMode)
if err != nil {
return err
} else if writer == nil {
return os.ErrInvalid
}
log.SetWriter(writer)
return nil
}
// Close formats the given parts with fmt.Sprint and logs the result with the Close level
func (log *BasicLogger) Close() error {
if log.writer != nil {
return log.writer.Close()
}
return nil
}
type logLine struct {
log *BasicLogger
Command string `json:"command"`
Time time.Time `json:"time"`
Level string `json:"level"`
Module string `json:"module"`
Message string `json:"message"`
Metadata map[string]interface{} `json:"metadata"`
}
func (ll logLine) String() string {
if len(ll.Module) == 0 {
return fmt.Sprintf("[%s] [%s] %s", ll.Time.Format(ll.log.TimeFormat), ll.Level, ll.Message)
} else {
return fmt.Sprintf("[%s] [%s/%s] %s", ll.Time.Format(ll.log.TimeFormat), ll.Module, ll.Level, ll.Message)
}
}
func reduceItem(m1, m2 map[string]interface{}) map[string]interface{} {
m3 := map[string]interface{}{}
_merge := func(m map[string]interface{}) {
for ia, va := range m {
m3[ia] = va
}
}
_merge(m1)
_merge(m2)
return m3
}
// Raw formats the given parts with fmt.Sprint and logs the result with the Raw level
func (log *BasicLogger) Raw(level Level, extraMetadata map[string]interface{}, module, origMessage string) {
message := logLine{log, "log", time.Now(), level.Name, module, strings.TrimSpace(origMessage), reduceItem(log.metadata, extraMetadata)}
if log.writer != nil {
log.writerLock.Lock()
var err error
if log.JSONFile {
err = log.fileEncoder.Encode(&message)
} else {
_, err = log.writer.WriteString(message.String())
_, _ = log.writer.WriteString("\n")
}
log.writerLock.Unlock()
if err != nil {
log.StderrLock.Lock()
_, _ = os.Stderr.WriteString("Failed to write to log file:")
_, _ = os.Stderr.WriteString(err.Error())
log.StderrLock.Unlock()
}
}
if level.Severity >= log.PrintLevel {
if log.JSONStdout {
log.StdoutLock.Lock()
_ = log.stdoutEncoder.Encode(&message)
log.StdoutLock.Unlock()
} else if level.Severity >= LevelError.Severity {
log.StderrLock.Lock()
_, _ = os.Stderr.WriteString(level.GetColor())
_, _ = os.Stderr.WriteString(message.String())
_, _ = os.Stderr.WriteString(level.GetReset())
_, _ = os.Stderr.WriteString("\n")
log.StderrLock.Unlock()
} else {
log.StdoutLock.Lock()
_, _ = os.Stdout.WriteString(level.GetColor())
_, _ = os.Stdout.WriteString(message.String())
_, _ = os.Stdout.WriteString(level.GetReset())
_, _ = os.Stdout.WriteString("\n")
log.StdoutLock.Unlock()
}
}
}