func (l *Logger) Print(v ...interface{}) {
	err := l.InfoLog.Output(callDepth, fmt.Sprintln(v...))
	if err != nil {
		fmt.Println("Logger Error:", err)
	}
}
Print writes log lines... to stdout and/or a file.
package logs
import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"runtime/debug"
	"github.com/Notifiarr/notifiarr/pkg/mnd"
	"github.com/Notifiarr/notifiarr/pkg/ui"
	homedir "github.com/mitchellh/go-homedir"
	"golift.io/rotatorr"
	"golift.io/rotatorr/timerotator"
)
type Logger struct {
	ErrorLog *log.Logger  
	DebugLog *log.Logger  
	InfoLog  *log.Logger
	HTTPLog  *log.Logger
	web      *rotatorr.Logger
	app      *rotatorr.Logger
	debug    *rotatorr.Logger
	custom   *rotatorr.Logger  
	logs     *LogConfig
}
var (
	logFiles  = 1
	logFileMb = 100
	customLog = make(map[string]*rotatorr.Logger)
)
var (
	ErrCloseCustom = fmt.Errorf("cannot close custom logs directly")
)
const (
	callDepth = 2  
	defExt    = ".log"
	httpExt   = ".http.log"
)
type LogConfig struct {
	AppName   string   `json:"-"`
	LogFile   string   `json:"log_file" toml:"log_file" xml:"log_file" yaml:"log_file"`
	DebugLog  string   `json:"debug_log" toml:"debug_log" xml:"debug_log" yaml:"debug_log"`
	HTTPLog   string   `json:"http_log" toml:"http_log" xml:"http_log" yaml:"http_log"`
	LogFiles  int      `json:"log_files" toml:"log_files" xml:"log_files" yaml:"log_files"`
	LogFileMb int      `json:"log_file_mb" toml:"log_file_mb" xml:"log_file_mb" yaml:"log_file_mb"`
	FileMode  FileMode `json:"file_mode" toml:"file_mode" xml:"file_mode" yaml:"file_mode"`
	Debug     bool     `json:"debug" toml:"debug" xml:"debug" yaml:"debug"`
	Quiet     bool     `json:"quiet" toml:"quiet" xml:"quiet" yaml:"quiet"`
}
func New() *Logger {
	return &Logger{
		DebugLog: log.New(ioutil.Discard, "[DEBUG] ", log.LstdFlags),
		InfoLog:  log.New(os.Stdout, "[INFO] ", log.LstdFlags),
		ErrorLog: log.New(os.Stdout, "[ERROR] ", log.LstdFlags),
		HTTPLog:  log.New(os.Stdout, "", log.LstdFlags),
		logs:     &LogConfig{},
	}
}
func (l *Logger) SetupLogging(config *LogConfig) {
	l.logs = config
	l.setDefaultLogPaths()
	l.setLogPaths()
	l.openLogFile()
	l.openHTTPLog()
	l.openDebugLog()
}
func (l *Logger) Rotate() (errors []error) {
	if l.custom != nil {
		if _, err := l.custom.Rotate(); err != nil {
			return []error{fmt.Errorf("rotating cCustom Log: %w", err)}
		}
	}
	for name, logger := range map[string]*rotatorr.Logger{
		"HTTP":  l.web,
		"App":   l.app,
		"Debug": l.debug,
	} {
		if logger != nil {
			if _, err := logger.Rotate(); err != nil {
				errors = append(errors, fmt.Errorf("closing %s Log: %w", name, err))
			}
		}
	}
	for name, logger := range customLog {
		if _, err := logger.Rotate(); err != nil {
			errors = append(errors, fmt.Errorf("rotating %s Log: %w", name, err))
		}
	}
	return errors
}
func (l *Logger) Close() (errors []error) {
	if l.custom != nil {
		return []error{ErrCloseCustom}
	}
	for name, logger := range map[string]*rotatorr.Logger{
		"HTTP":  l.web,
		"App":   l.app,
		"Debug": l.debug,
	} {
		if logger != nil {
			if err := logger.Close(); err != nil {
				errors = append(errors, fmt.Errorf("closing %s Log: %w", name, err))
			}
		}
	}
	l.web = nil
	l.app = nil
	l.debug = nil
	for name, logger := range customLog {
		if err := logger.Close(); err != nil {
			errors = append(errors, fmt.Errorf("closing %s Log: %w", name, err))
		}
		delete(customLog, name)
	}
	return errors
}
func (l *Logger) CapturePanic() {
	if r := recover(); r != nil {
		ui.ShowConsoleWindow()
		l.ErrorLog.Output(callDepth,  
			fmt.Sprintf("Go Panic! %s\n%v\n%s", mnd.BugIssue, r, string(debug.Stack())))
		panic(r)
	}
}
func (l *Logger) Debug(v ...interface{}) {
	err := l.DebugLog.Output(callDepth, fmt.Sprintln(v...))
	if err != nil {
		fmt.Println("Logger Error:", err)
	}
}
func (l *Logger) Debugf(msg string, v ...interface{}) {
	err := l.DebugLog.Output(callDepth, fmt.Sprintf(msg, v...))
	if err != nil {
		fmt.Println("Logger Error:", err)
	}
}