"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files
Go azure-blobazure-blob-storageazure-filesbackblaze-b2cloud-storagedropboxencryptionftpfuse-filesystemgogolanggoogle-cloud-storagegoogle-driveonedriveopenstack-swiftrclones3sftpsyncwebdav
fs: Remove github.com/sirupsen/logrus and replace with log/slog
Nick Craig-Wooddfa4d948279f
diff --git a/cmd/bisync/bilib/output.go b/cmd/bisync/bilib/output.goindex c35abde86..00ac8d78e 100644--- a/cmd/bisync/bilib/output.go+++ b/cmd/bisync/bilib/output.go@@ -3,20 +3,22 @@ package bilibimport ("bytes"- "log"+ "log/slog"- "github.com/sirupsen/logrus"+ "github.com/rclone/rclone/fs/log")-// CaptureOutput runs a function capturing its output.+// CaptureOutput runs a function capturing its output at log level INFO.func CaptureOutput(fun func()) []byte {- logSave := log.Writer()- logrusSave := logrus.StandardLogger().Outbuf := &bytes.Buffer{}- log.SetOutput(buf)- logrus.SetOutput(buf)+ oldLevel := log.Handler.SetLevel(slog.LevelInfo)+ log.Handler.SetOutput(func(level slog.Level, text string) {+ buf.WriteString(text)+ })+ defer func() {+ log.Handler.ResetOutput()+ log.Handler.SetLevel(oldLevel)+ }()fun()- log.SetOutput(logSave)- logrus.SetOutput(logrusSave)return buf.Bytes()}diff --git a/cmd/ncdu/ncdu.go b/cmd/ncdu/ncdu.goindex dfe994a63..41dbcd75a 100644--- a/cmd/ncdu/ncdu.go+++ b/cmd/ncdu/ncdu.go@@ -6,6 +6,8 @@ package ncduimport ("context""fmt"+ "log/slog"+ "os""path""reflect""sort"@@ -925,23 +927,19 @@ func (u *UI) Run() error {return fmt.Errorf("screen init: %w", err)}- // Hijack fs.LogOutput so that it doesn't corrupt the screen.- if logOutput := fs.LogOutput; !log.Redirected() {- type log struct {- text string- level fs.LogLevel- }- var logs []log- fs.LogOutput = func(level fs.LogLevel, text string) {+ // Hijack log output so that it doesn't corrupt the screen.+ if !log.Redirected() {+ var logs []string+ log.Handler.SetOutput(func(level slog.Level, text string) {if len(logs) > 100 {logs = logs[len(logs)-100:]}- logs = append(logs, log{level: level, text: text})- }+ logs = append(logs, text)+ })defer func() {- fs.LogOutput = logOutput- for i := range logs {- logOutput(logs[i].level, logs[i].text)+ log.Handler.ResetOutput()+ for _, text := range logs {+ _, _ = os.Stderr.WriteString(text)}}()}diff --git a/cmd/progress.go b/cmd/progress.goindex 2963ad396..539f0b801 100644--- a/cmd/progress.go+++ b/cmd/progress.go@@ -5,11 +5,11 @@ package cmdimport ("bytes""fmt"+ "log/slog""strings""sync""time"- "github.com/rclone/rclone/fs""github.com/rclone/rclone/fs/accounting""github.com/rclone/rclone/fs/log""github.com/rclone/rclone/fs/operations"@@ -19,8 +19,6 @@ import (const (// interval between progress printsdefaultProgressInterval = 500 * time.Millisecond- // time format for logging- logTimeFormat = "2006/01/02 15:04:05")// startProgress starts the progress bar printing@@ -28,15 +26,13 @@ const (// It returns a func which should be called to stop the stats.func startProgress() func() {stopStats := make(chan struct{})- oldLogOutput := fs.LogOutputoldSyncPrint := operations.SyncPrintfif !log.Redirected() {// Intercept the log calls if not logging to file or syslog- fs.LogOutput = func(level fs.LogLevel, text string) {- printProgress(fmt.Sprintf("%s %-6s: %s", time.Now().Format(logTimeFormat), level, text))-- }+ log.Handler.SetOutput(func(level slog.Level, text string) {+ printProgress(text)+ })}// Intercept output from functions such as HashLister to stdout@@ -60,7 +56,10 @@ func startProgress() func() {case <-stopStats:ticker.Stop()printProgress("")- fs.LogOutput = oldLogOutput+ if !log.Redirected() {+ // Reset intercept of the log calls+ log.Handler.ResetOutput()+ }operations.SyncPrintf = oldSyncPrintfmt.Println("")returndiff --git a/cmdtest/environment_test.go b/cmdtest/environment_test.goindex 47410c687..86ab0b4de 100644--- a/cmdtest/environment_test.go+++ b/cmdtest/environment_test.go@@ -48,7 +48,7 @@ func TestEnvironmentVariables(t *testing.T) {env = "RCLONE_LOG_LEVEL=DEBUG"out, err = rcloneEnv(env, "version", "--quiet")if assert.Error(t, err) {- assert.Contains(t, out, " DEBUG : ")+ assert.Contains(t, out, " DEBUG ")assert.Contains(t, out, "Can't set -q and --log-level")assert.Contains(t, "exit status 1", err.Error())}@@ -329,7 +329,7 @@ func TestEnvironmentVariables(t *testing.T) {jsonLogOK := func() {t.Helper()if assert.NoError(t, err) {- assert.Contains(t, out, `{"level":"debug",`)+ assert.Contains(t, out, `"level":"debug"`)assert.Contains(t, out, `"msg":"Version `)assert.Contains(t, out, `"}`)}diff --git a/docs/content/docs.md b/docs/content/docs.mdindex 7bbbbd1fe..95ca98c65 100644--- a/docs/content/docs.md+++ b/docs/content/docs.md@@ -1483,12 +1483,21 @@ have a signal to rotate logs.### --log-format LIST ###-Comma separated list of log format options. Accepted options are `date`,-`time`, `microseconds`, `pid`, `longfile`, `shortfile`, `UTC`. Any other-keywords will be silently ignored. `pid` will tag log messages with process-identifier which useful with `rclone mount --daemon`. Other accepted-options are explained in the [go documentation](https://pkg.go.dev/log#pkg-constants).-The default log format is "`date`,`time`".+Comma separated list of log format options. The accepted options are:++- `date` - Add a date in the format YYYY/MM/YY to the log.+- `time` - Add a time to the log in format HH:MM:SS.+- `microseconds` - Add microseconds to the time in format HH:MM:SS.SSSSSS.+- `UTC` - Make the logs in UTC not localtime.+- `longfile` - Adds the source file and line number of the log statement.+- `shortfile` - Adds the source file and line number of the log statement.+- `pid` - Add the process ID to the log - useful with `rclone mount --daemon`.+- `nolevel` - Don't add the level to the log.+- `json` - Equivalent to adding `--use-json-log`++They are added to the log line in the order above.++The default log format is `"date,time"`.### --log-level LEVEL ###@@ -1508,8 +1517,61 @@ warnings and significant events.### --use-json-log ###-This switches the log format to JSON for rclone. The fields of json log-are level, msg, source, time.+This switches the log format to JSON for rclone. The fields of JSON+log are `level`, `msg`, `source`, `time`. The JSON logs will be+printed on a single line, but are shown expanded here for clarity.++```json+{+ "time": "2025-05-13T17:30:51.036237518+01:00",+ "level": "debug",+ "msg": "4 go routines active\n",+ "source": "cmd/cmd.go:298"+}+```++Completed data transfer logs will have extra `size` information. Logs+which are about a particular object will have `object` and+`objectType` fields also.++```json+{+ "time": "2025-05-13T17:38:05.540846352+01:00",+ "level": "info",+ "msg": "Copied (new) to: file2.txt",+ "size": 6,+ "object": "file.txt",+ "objectType": "*local.Object",+ "source": "operations/copy.go:368"+}+```++Stats logs will contain a `stats` field which is the same as+returned from the rc call [core/stats](/rc/#core-stats).++```json+{+ "time": "2025-05-13T17:38:05.540912847+01:00",+ "level": "info",+ "msg": "...text version of the stats...",+ "stats": {+ "bytes": 6,+ "checks": 0,+ "deletedDirs": 0,+ "deletes": 0,+ "elapsedTime": 0.000904825,+ ...truncated for clarity...+ "totalBytes": 6,+ "totalChecks": 0,+ "totalTransfers": 1,+ "transferTime": 0.000882794,+ "transfers": 1+ },+ "source": "accounting/stats.go:569"+}+```++### --low-level-retries NUMBER ###diff --git a/fs/config.go b/fs/config.goindex e8f0dee8c..0d3f9ddc5 100644--- a/fs/config.go+++ b/fs/config.go@@ -671,9 +671,13 @@ func init() {RegisterGlobalOptions(OptionsInfo{Name: "main", Opt: globalConfig, Options: ConfigOptionsInfo, Reload: globalConfig.Reload})// initial guess at log level from the flags- globalConfig.LogLevel = initialLogLevel()+ globalConfig.LogLevel = InitialLogLevel()}+// LogReload is written by fs/log to set variables which should really+// be there but we can't move due to them being visible here in the rc.+var LogReload = func(*ConfigInfo) error { return nil }+// Reload assumes the config has been edited and does what is necessary to make it livefunc (ci *ConfigInfo) Reload(ctx context.Context) error {// Set -vv if --dump is in use@@ -687,11 +691,6 @@ func (ci *ConfigInfo) Reload(ctx context.Context) error {ci.StatsLogLevel = LogLevelNotice}- // If --use-json-log then start the JSON logger- if ci.UseJSONLog {- InstallJSONLogger(ci.LogLevel)- }-// Check --compare-dest and --copy-destif len(ci.CompareDest) > 0 && len(ci.CopyDest) > 0 {return fmt.Errorf("can't use --compare-dest with --copy-dest")@@ -731,13 +730,12 @@ func (ci *ConfigInfo) Reload(ctx context.Context) error {nonZero(&ci.Transfers)nonZero(&ci.Checkers)- return nil+ return LogReload(ci)}-// Initial logging level-//-// Perform a simple check for debug flags to enable debug logging during the flag initialization-func initialLogLevel() LogLevel {+// InitialLogLevel performs a simple check for debug flags to enable+// debug logging during the flag initialization.+func InitialLogLevel() LogLevel {logLevel := LogLevelNoticefor argIndex, arg := range os.Args {if strings.HasPrefix(arg, "-vv") && strings.TrimRight(arg, "v") == "-" {diff --git a/fs/log.go b/fs/log.goindex d7efc5b61..98350b021 100644--- a/fs/log.go+++ b/fs/log.go@@ -4,10 +4,9 @@ import ("context""encoding/json""fmt"- "log"+ "log/slog""os"-- "github.com/sirupsen/logrus"+ "slices")// LogLevel describes rclone's logs. These are a subset of the syslog log levels.@@ -54,19 +53,31 @@ func (logLevelChoices) Type() string {return "LogLevel"}-// LogPrintPid enables process pid in log-var LogPrintPid = false--// InstallJSONLogger is a hook that --use-json-log calls-var InstallJSONLogger = func(logLevel LogLevel) {}+// slogLevel definitions defined as slog.Level constants.+// The integer values determine severity for filtering.+// Lower values are less severe (e.g., Debug), higher values are more severe (e.g., Emergency).+// We fit our extra values into slog's scale.+const (+ // slog.LevelDebug slog.Level = -4+ // slog.LevelInfo slog.Level = 0+ SlogLevelNotice = slog.Level(2) // Between Info (0) and Warn (4)+ // slog.LevelWarn slog.Level = 4+ // slog.LevelError slog.Level = 8+ SlogLevelCritical = slog.Level(12) // More severe than Error+ SlogLevelAlert = slog.Level(16) // More severe than Critical+ SlogLevelEmergency = slog.Level(20) // Most severe+)-// LogOutput sends the text to the logger of level-var LogOutput = func(level LogLevel, text string) {- text = fmt.Sprintf("%-6s: %s", level, text)- if LogPrintPid {- text = fmt.Sprintf("[%d] %s", os.Getpid(), text)- }- _ = log.Output(4, text)+// Map our level numbers to slog level numbers+var levelToSlog = []slog.Level{+ LogLevelEmergency: SlogLevelEmergency,+ LogLevelAlert: SlogLevelAlert,+ LogLevelCritical: SlogLevelCritical,+ LogLevelError: slog.LevelError,+ LogLevelWarning: slog.LevelWarn,+ LogLevelNotice: SlogLevelNotice,+ LogLevelInfo: slog.LevelInfo,+ LogLevelDebug: slog.LevelDebug,}// LogValueItem describes keyed item for a JSON log entry@@ -108,76 +119,45 @@ func (j LogValueItem) String() string {return fmt.Sprint(j.value)}-func logLogrus(level LogLevel, text string, fields logrus.Fields) {- switch level {- case LogLevelDebug:- logrus.WithFields(fields).Debug(text)- case LogLevelInfo:- logrus.WithFields(fields).Info(text)- case LogLevelNotice, LogLevelWarning:- logrus.WithFields(fields).Warn(text)- case LogLevelError:- logrus.WithFields(fields).Error(text)- case LogLevelCritical:- logrus.WithFields(fields).Fatal(text)- case LogLevelEmergency, LogLevelAlert:- logrus.WithFields(fields).Panic(text)- }-}--func logLogrusWithObject(level LogLevel, o any, text string, fields logrus.Fields) {- if o != nil {- if fields == nil {- fields = logrus.Fields{}- }- fields["object"] = fmt.Sprintf("%+v", o)- fields["objectType"] = fmt.Sprintf("%T", o)+// LogLevelToSlog converts an rclone log level to log/slog log level.+func LogLevelToSlog(level LogLevel) slog.Level {+ slogLevel := slog.LevelError+ // NB level is unsigned so we don't check < 0 here+ if int(level) < len(levelToSlog) {+ slogLevel = levelToSlog[level]}- logLogrus(level, text, fields)-}--func logJSON(level LogLevel, o any, text string) {- logLogrusWithObject(level, o, text, nil)+ return slogLevel}-func logJSONf(level LogLevel, o any, text string, args ...any) {- text = fmt.Sprintf(text, args...)- fields := logrus.Fields{}- for _, arg := range args {- if item, ok := arg.(LogValueItem); ok {- fields[item.key] = item.value- }- }- logLogrusWithObject(level, o, text, fields)+func logSlog(level LogLevel, text string, attrs []any) {+ slog.Log(context.Background(), LogLevelToSlog(level), text, attrs...)}-func logPlain(level LogLevel, o any, text string) {+func logSlogWithObject(level LogLevel, o any, text string, attrs []any) {if o != nil {- text = fmt.Sprintf("%v: %s", o, text)+ attrs = slices.Concat(attrs, []any{+ "object", fmt.Sprintf("%+v", o),+ "objectType", fmt.Sprintf("%T", o),+ })}- LogOutput(level, text)-}--func logPlainf(level LogLevel, o any, text string, args ...any) {- logPlain(level, o, fmt.Sprintf(text, args...))+ logSlog(level, text, attrs)}// LogPrint produces a log string from the arguments passed infunc LogPrint(level LogLevel, o any, text string) {- if GetConfig(context.TODO()).UseJSONLog {- logJSON(level, o, text)- } else {- logPlain(level, o, text)- }+ logSlogWithObject(level, o, text, nil)}// LogPrintf produces a log string from the arguments passed infunc LogPrintf(level LogLevel, o any, text string, args ...any) {- if GetConfig(context.TODO()).UseJSONLog {- logJSONf(level, o, text, args...)- } else {- logPlainf(level, o, text, args...)+ text = fmt.Sprintf(text, args...)+ var fields []any+ for _, arg := range args {+ if item, ok := arg.(LogValueItem); ok {+ fields = append(fields, item.key, item.value)+ }}+ logSlogWithObject(level, o, text, fields)}// LogLevelPrint writes logs at the given leveldiff --git a/fs/log/caller_hook.go b/fs/log/caller_hook.godeleted file mode 100644index dd2c5c470..000000000--- a/fs/log/caller_hook.go+++ /dev/null@@ -1,106 +0,0 @@-package log--import (- "fmt"- "runtime"- "strings"-- "github.com/rclone/rclone/fs"- "github.com/sirupsen/logrus"-)--var loggerInstalled = false--// InstallJSONLogger installs the JSON logger at the specified log level-func InstallJSONLogger(logLevel fs.LogLevel) {- if !loggerInstalled {- logrus.AddHook(NewCallerHook())- loggerInstalled = true- }- logrus.SetFormatter(&logrus.JSONFormatter{- TimestampFormat: "2006-01-02T15:04:05.999999-07:00",- })- logrus.SetLevel(logrus.DebugLevel)- switch logLevel {- case fs.LogLevelEmergency, fs.LogLevelAlert:- logrus.SetLevel(logrus.PanicLevel)- case fs.LogLevelCritical:- logrus.SetLevel(logrus.FatalLevel)- case fs.LogLevelError:- logrus.SetLevel(logrus.ErrorLevel)- case fs.LogLevelWarning, fs.LogLevelNotice:- logrus.SetLevel(logrus.WarnLevel)- case fs.LogLevelInfo:- logrus.SetLevel(logrus.InfoLevel)- case fs.LogLevelDebug:- logrus.SetLevel(logrus.DebugLevel)- }-}--// install hook in fs to call to avoid circular dependency-func init() {- fs.InstallJSONLogger = InstallJSONLogger-}--// CallerHook for log the calling file and line of the fine-type CallerHook struct {- Field string- Skip int- levels []logrus.Level-}--// NewCallerHook use to make a hook-func NewCallerHook(levels ...logrus.Level) logrus.Hook {- hook := CallerHook{- Field: "source",- Skip: 7,- levels: levels,- }- if len(hook.levels) == 0 {- hook.levels = logrus.AllLevels- }- return &hook-}--// Levels implement applied hook to which levels-func (h *CallerHook) Levels() []logrus.Level {- return logrus.AllLevels-}--// Fire logs the information of context (filename and line)-func (h *CallerHook) Fire(entry *logrus.Entry) error {- entry.Data[h.Field] = findCaller(h.Skip)- return nil-}--// findCaller ignores the caller relevant to logrus or fslog then find out the exact caller-func findCaller(skip int) string {- file := ""- line := 0- for i := range 10 {- file, line = getCaller(skip + i)- if !strings.HasPrefix(file, "logrus") && !strings.Contains(file, "log.go") {- break- }- }- return fmt.Sprintf("%s:%d", file, line)-}--func getCaller(skip int) (string, int) {- _, file, line, ok := runtime.Caller(skip)- // fmt.Println(file,":",line)- if !ok {- return "", 0- }- n := 0- for i := len(file) - 1; i > 0; i-- {- if file[i] == '/' {- n++- if n >= 2 {- file = file[i+1:]- break- }- }- }- return file, line-}diff --git a/fs/log/log.go b/fs/log/log.goindex 2e4df791b..b94f4d621 100644--- a/fs/log/log.go+++ b/fs/log/log.go@@ -4,14 +4,12 @@ package logimport ("context""io"- "log""os""reflect""runtime""strings""github.com/rclone/rclone/fs"- "github.com/sirupsen/logrus")// OptionsInfo descripts the Options in use@@ -22,7 +20,7 @@ var OptionsInfo = fs.Options{{Groups: "Logging",}, {Name: "log_format",- Default: "date,time",+ Default: logFormatDate | logFormatTime,Help: "Comma separated list of log format options",Groups: "Logging",}, {@@ -44,11 +42,11 @@ var OptionsInfo = fs.Options{{// Options contains options for controlling the loggingtype Options struct {- File string `config:"log_file"` // Log everything to this file- Format string `config:"log_format"` // Comma separated list of log format options- UseSyslog bool `config:"syslog"` // Use Syslog for logging- SyslogFacility string `config:"syslog_facility"` // Facility for syslog, e.g. KERN,USER,...- LogSystemdSupport bool `config:"log_systemd"` // set if using systemd logging+ File string `config:"log_file"` // Log everything to this file+ Format logFormat `config:"log_format"` // Comma separated list of log format options+ UseSyslog bool `config:"syslog"` // Use Syslog for logging+ SyslogFacility string `config:"syslog_facility"` // Facility for syslog, e.g. KERN,USER,...+ LogSystemdSupport bool `config:"log_systemd"` // set if using systemd logging}func init() {@@ -58,6 +56,37 @@ func init() {// Opt is the options for the loggervar Opt Options+// enum for the log format+type logFormat = fs.Bits[logFormatChoices]++const (+ logFormatDate logFormat = 1 << iota+ logFormatTime+ logFormatMicroseconds+ logFormatUTC+ logFormatLongFile+ logFormatShortFile+ logFormatPid+ logFormatNoLevel+ logFormatJSON+)++type logFormatChoices struct{}++func (logFormatChoices) Choices() []fs.BitsChoicesInfo {+ return []fs.BitsChoicesInfo{+ {Bit: uint64(logFormatDate), Name: "date"},+ {Bit: uint64(logFormatTime), Name: "time"},+ {Bit: uint64(logFormatMicroseconds), Name: "microseconds"},+ {Bit: uint64(logFormatUTC), Name: "UTC"},+ {Bit: uint64(logFormatLongFile), Name: "longfile"},+ {Bit: uint64(logFormatShortFile), Name: "shortfile"},+ {Bit: uint64(logFormatPid), Name: "pid"},+ {Bit: uint64(logFormatNoLevel), Name: "nolevel"},+ {Bit: uint64(logFormatJSON), Name: "json"},+ }+}+// fnName returns the name of the calling +2 functionfunc fnName() string {pc, _, _, ok := runtime.Caller(2)@@ -114,31 +143,24 @@ func Stack(o any, info string) {fs.LogPrintf(fs.LogLevelDebug, o, "%s\nStack trace:\n%s", info, buf)}+// This is called from fs when the config is reloaded+//+// The config should really be here but we can't move it as it is+// externally visible in the rc.+func logReload(ci *fs.ConfigInfo) error {+ Handler.SetLevel(fs.LogLevelToSlog(ci.LogLevel))+ return nil+}++func init() {+ fs.LogReload = logReload+}+// InitLogging start the logging as per the command line flagsfunc InitLogging() {- flagsStr := "," + Opt.Format + ","- var flags int- if strings.Contains(flagsStr, ",date,") {- flags |= log.Ldate- }- if strings.Contains(flagsStr, ",time,") {- flags |= log.Ltime- }- if strings.Contains(flagsStr, ",microseconds,") {- flags |= log.Lmicroseconds- }- if strings.Contains(flagsStr, ",UTC,") {- flags |= log.LUTC- }- if strings.Contains(flagsStr, ",longfile,") {- flags |= log.Llongfile- }- if strings.Contains(flagsStr, ",shortfile,") {- flags |= log.Lshortfile- }- log.SetFlags(flags)-- fs.LogPrintPid = strings.Contains(flagsStr, ",pid,")+ // Note that ci only has the defaults in at this point+ // We set real values in logReload+ ci := fs.GetConfig(context.Background())// Log file outputif Opt.File != "" {@@ -150,17 +172,27 @@ func InitLogging() {if err != nil {fs.Errorf(nil, "Failed to seek log file to end: %v", err)}- log.SetOutput(f)- logrus.SetOutput(f)redirectStderr(f)+ Handler.setWriter(f)+ }++ // --use-json-log implies JSON formatting+ if ci.UseJSONLog {+ Opt.Format |= logFormatJSON}+ // Set slog level to initial log level+ Handler.SetLevel(fs.LogLevelToSlog(fs.InitialLogLevel()))++ // Set the format to the configured format+ Handler.setFormat(Opt.Format)+// Syslog outputif Opt.UseSyslog {if Opt.File != "" {fs.Fatalf(nil, "Can't use --syslog and --log-file together")}- startSysLog()+ startSysLog(Handler)}// Activate systemd logger support if systemd invocation ID is@@ -173,7 +205,7 @@ func InitLogging() {// Systemd logging outputif Opt.LogSystemdSupport {- startSystemdLog()+ startSystemdLog(Handler)}}diff --git a/fs/log/slog.go b/fs/log/slog.gonew file mode 100644index 000000000..10b64a610--- /dev/null+++ b/fs/log/slog.go@@ -0,0 +1,391 @@+// Interfaces for the slog package++package log++import (+ "bytes"+ "context"+ "fmt"+ "io"+ "log/slog"+ "os"+ "runtime"+ "strings"+ "sync"+ "time"++ "github.com/rclone/rclone/fs"+)++// Handler is the standard handler for the logging.+var Handler = defaultHandler()++// Create the default OutputHandler+//+// This logs to stderr with standard go logger format at level INFO.+//+// This will be adjusted by InitLogging to be the configured levels+// but it is important we have a logger running regardless of whether+// InitLogging has been called yet or not.+func defaultHandler() *OutputHandler {+ // Default options for default handler+ var opts = &slog.HandlerOptions{+ Level: fs.LogLevelToSlog(fs.InitialLogLevel()),+ }++ // Create our handler+ h := NewOutputHandler(os.Stderr, opts, logFormatDate|logFormatTime)++ // Set the slog default handler+ slog.SetDefault(slog.New(h))++ // Make log.Printf logs at level Notice+ slog.SetLogLoggerLevel(fs.SlogLevelNotice)++ return h+}++// Map slog level names to string+var slogNames = map[slog.Level]string{+ slog.LevelDebug: "DEBUG",+ slog.LevelInfo: "INFO",+ fs.SlogLevelNotice: "NOTICE",+ slog.LevelWarn: "WARNING",+ slog.LevelError: "ERROR",+ fs.SlogLevelCritical: "CRITICAL",+ fs.SlogLevelAlert: "ALERT",+ fs.SlogLevelEmergency: "EMERGENCY",+}++// Convert a slog level to string using rclone's extra levels+func slogLevelToString(level slog.Level) string {+ levelStr := slogNames[level]+ if levelStr == "" {+ levelStr = level.String()+ }+ return levelStr+}++// ReplaceAttr function to customize the level key's string value in logs+func mapLogLevelNames(groups []string, a slog.Attr) slog.Attr {+ if a.Key == slog.LevelKey {+ level, ok := a.Value.Any().(slog.Level)+ if !ok {+ return a+ }+ levelStr := strings.ToLower(slogLevelToString(level))+ a.Value = slog.StringValue(levelStr)+ }+ return a+}++// get the file and line number of the caller skipping skip levels+func getCaller(skip int) string {+ var pc [64]uintptr+ n := runtime.Callers(skip, pc[:])+ if n == 0 {+ return ""+ }+ frames := runtime.CallersFrames(pc[:n])+ var more = true+ var frame runtime.Frame+ for more {+ frame, more = frames.Next()++ file := frame.File+ if strings.Contains(file, "/log/") || strings.HasSuffix(file, "log.go") {+ continue+ }+ line := frame.Line++ // shorten file name+ n := 0+ for i := len(file) - 1; i > 0; i-- {+ if file[i] == '/' {+ n+++ if n >= 2 {+ file = file[i+1:]+ break+ }+ }+ }+ return fmt.Sprintf("%s:%d", file, line)+ }+ return ""+}++// OutputHandler is a slog.Handler that writes log records in a format+// identical to the standard library's `log` package (e.g., "YYYY/MM/DD HH:MM:SS message").+//+// It can also write logs in JSON format identical to logrus.+type OutputHandler struct {+ opts slog.HandlerOptions+ levelVar slog.LevelVar+ writer io.Writer+ mu sync.Mutex+ output []outputFn // log to writer if empty or the last item+ outputExtra []outputExtra // log to all these additional places+ format logFormat+ jsonBuf bytes.Buffer+ jsonHandler *slog.JSONHandler+}++// Records the type and function pointer for extra logging output.+type outputExtra struct {+ json bool+ output outputFn+}++// Define the type of the override logger+type outputFn func(level slog.Level, text string)++// NewOutputHandler creates a new OutputHandler with the specified flags.+//+// This is designed to use log/slog but produce output which is+// backwards compatible with previous rclone versions.+//+// If opts is nil, default options are used, with Level set to+// slog.LevelInfo.+func NewOutputHandler(out io.Writer, opts *slog.HandlerOptions, format logFormat) *OutputHandler {+ h := &OutputHandler{+ writer: out,+ format: format,+ }+ if opts != nil {+ h.opts = *opts+ }+ if h.opts.Level == nil {+ h.opts.Level = slog.LevelInfo+ }+ // Set the level var with the configured level+ h.levelVar.Set(h.opts.Level.Level())+ // And use it from now on+ h.opts.Level = &h.levelVar++ // Create the JSON logger in case we need it+ jsonOpts := slog.HandlerOptions{+ Level: h.opts.Level,+ ReplaceAttr: mapLogLevelNames,+ }+ h.jsonHandler = slog.NewJSONHandler(&h.jsonBuf, &jsonOpts)+ return h+}++// SetOutput sets a new output handler for the log output.+//+// This is for temporarily overriding the output.+func (h *OutputHandler) SetOutput(fn outputFn) {+ h.output = append(h.output, fn)+}++// ResetOutput resets the log output to what is was.+func (h *OutputHandler) ResetOutput() {+ if len(h.output) > 0 {+ h.output = h.output[:len(h.output)-1]+ }+}++// AddOutput adds an additional logging destination of the type specified.+func (h *OutputHandler) AddOutput(json bool, fn outputFn) {+ h.outputExtra = append(h.outputExtra, outputExtra{+ json: json,+ output: fn,+ })+}++// SetLevel sets a new log level, returning the old one.+func (h *OutputHandler) SetLevel(level slog.Level) slog.Level {+ oldLevel := h.levelVar.Level()+ h.levelVar.Set(level)+ return oldLevel+}++// Set the writer for the log to that passed.+func (h *OutputHandler) setWriter(writer io.Writer) {+ h.writer = writer+}++// Set the format flags to that passed in.+func (h *OutputHandler) setFormat(format logFormat) {+ h.format = format+}++// clear format flags that this output type doesn't want+func (h *OutputHandler) clearFormatFlags(bitMask logFormat) {+ h.format &^= bitMask+}++// set format flags that this output type requires+func (h *OutputHandler) setFormatFlags(bitMask logFormat) {+ h.format |= bitMask+}++// Enabled returns whether this logger is enabled for this level.+func (h *OutputHandler) Enabled(_ context.Context, level slog.Level) bool {+ minLevel := slog.LevelInfo+ if h.opts.Level != nil {+ minLevel = h.opts.Level.Level()+ }+ return level >= minLevel+}++// Create a log header in Go standard log format.+func (h *OutputHandler) formatStdLogHeader(buf *bytes.Buffer, level slog.Level, t time.Time, object string, lineInfo string) {+ // Add time in Go standard format if requested+ if h.format&(logFormatDate|logFormatTime|logFormatMicroseconds) != 0 {+ if h.format&logFormatUTC != 0 {+ t = t.UTC()+ }+ if h.format&logFormatDate != 0 {+ year, month, day := t.Date()+ fmt.Fprintf(buf, "%04d/%02d/%02d ", year, month, day)+ }+ if h.format&(logFormatTime|logFormatMicroseconds) != 0 {+ hour, min, sec := t.Clock()+ fmt.Fprintf(buf, "%02d:%02d:%02d", hour, min, sec)+ if h.format&logFormatMicroseconds != 0 {+ fmt.Fprintf(buf, ".%06d", t.Nanosecond()/1e3)+ }+ buf.WriteByte(' ')+ }+ }+ // Add source code filename:line if requested+ if h.format&(logFormatShortFile|logFormatLongFile) != 0 && lineInfo != "" {+ buf.WriteString(lineInfo)+ buf.WriteByte(':')+ buf.WriteByte(' ')+ }+ // Add PID if requested+ if h.format&logFormatPid != 0 {+ fmt.Fprintf(buf, "[%d] ", os.Getpid())+ }+ // Add log level if required+ if h.format&logFormatNoLevel == 0 {+ levelStr := slogLevelToString(level)+ fmt.Fprintf(buf, "%-6s: ", levelStr)+ }+ // Add object if passed+ if object != "" {+ buf.WriteString(object)+ buf.WriteByte(':')+ buf.WriteByte(' ')+ }+}++// Create a log in standard Go log format into buf.+func (h *OutputHandler) textLog(ctx context.Context, buf *bytes.Buffer, r slog.Record) error {+ var lineInfo string+ if h.format&(logFormatShortFile|logFormatLongFile) != 0 {+ lineInfo = getCaller(2)+ }++ var object string+ r.Attrs(func(attr slog.Attr) bool {+ if attr.Key == "object" {+ object = attr.Value.String()+ return false+ }+ return true+ })++ h.formatStdLogHeader(buf, r.Level, r.Time, object, lineInfo)+ buf.WriteString(r.Message)+ if buf.Len() == 0 || buf.Bytes()[buf.Len()-1] != '\n' { // Ensure newline+ buf.WriteByte('\n')+ }+ return nil+}++// Create a log in JSON format into buf.+func (h *OutputHandler) jsonLog(ctx context.Context, buf *bytes.Buffer, r slog.Record) (err error) {+ // Call the JSON handler to create the JSON in buf+ r.AddAttrs(+ slog.String("source", getCaller(2)),+ )+ h.mu.Lock()+ err = h.jsonHandler.Handle(ctx, r)+ if err == nil {+ _, err = h.jsonBuf.WriteTo(buf)+ }+ h.mu.Unlock()+ return err+}++// Handle outputs a log in the current format+func (h *OutputHandler) Handle(ctx context.Context, r slog.Record) (err error) {+ var (+ bufJSON *bytes.Buffer+ bufText *bytes.Buffer+ buf *bytes.Buffer+ )++ // Check whether we need to build Text or JSON logs or both+ needJSON := h.format&logFormatJSON != 0+ needText := !needJSON+ for _, out := range h.outputExtra {+ if out.json {+ needJSON = true+ } else {+ needText = true+ }+ }++ if needJSON {+ var bufJSONBack [256]byte+ bufJSON = bytes.NewBuffer(bufJSONBack[:0])+ err = h.jsonLog(ctx, bufJSON, r)+ if err != nil {+ return err+ }+ }++ if needText {+ var bufTextBack [256]byte+ bufText = bytes.NewBuffer(bufTextBack[:0])+ err = h.textLog(ctx, bufText, r)+ if err != nil {+ return err+ }+ }++ h.mu.Lock()+ defer h.mu.Unlock()++ // Do the log, either to the default destination or to the alternate logging system+ if h.format&logFormatJSON != 0 {+ buf = bufJSON+ } else {+ buf = bufText+ }+ if len(h.output) > 0 {+ h.output[len(h.output)-1](r.Level, buf.String())+ err = nil+ } else {+ _, err = h.writer.Write(buf.Bytes())+ }++ // Log to any additional destinations required+ for _, out := range h.outputExtra {+ if out.json {+ out.output(r.Level, bufJSON.String())+ } else {+ out.output(r.Level, bufText.String())+ }+ }+ return err+}++// WithAttrs creates a new handler with the same writer, options, and flags.+// Attributes are ignored for the output format of this specific handler.+func (h *OutputHandler) WithAttrs(attrs []slog.Attr) slog.Handler {+ return NewOutputHandler(h.writer, &h.opts, h.format)+}++// WithGroup creates a new handler with the same writer, options, and flags.+// Groups are ignored for the output format of this specific handler.+func (h *OutputHandler) WithGroup(name string) slog.Handler {+ return NewOutputHandler(h.writer, &h.opts, h.format)+}++// Check interface+var _ slog.Handler = (*OutputHandler)(nil)diff --git a/fs/log/slog_test.go b/fs/log/slog_test.gonew file mode 100644index 000000000..5cfa52131--- /dev/null+++ b/fs/log/slog_test.go@@ -0,0 +1,264 @@+package log++import (+ "bytes"+ "context"+ "fmt"+ "os"+ "regexp"+ "strings"+ "testing"+ "time"++ "log/slog"++ "github.com/rclone/rclone/fs"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++var (+ utcPlusOne = time.FixedZone("UTC+1", 1*60*60)+ t0 = time.Date(2020, 1, 2, 3, 4, 5, 123456000, utcPlusOne)+)++// Test slogLevelToString covers all mapped levels and an unknown level.+func TestSlogLevelToString(t *testing.T) {+ tests := []struct {+ level slog.Level+ want string+ }{+ {slog.LevelDebug, "DEBUG"},+ {slog.LevelInfo, "INFO"},+ {fs.SlogLevelNotice, "NOTICE"},+ {slog.LevelWarn, "WARNING"},+ {slog.LevelError, "ERROR"},+ {fs.SlogLevelCritical, "CRITICAL"},+ {fs.SlogLevelAlert, "ALERT"},+ {fs.SlogLevelEmergency, "EMERGENCY"},+ // Unknown level should fall back to .String()+ {slog.Level(1234), slog.Level(1234).String()},+ }+ for _, tc := range tests {+ got := slogLevelToString(tc.level)+ assert.Equal(t, tc.want, got)+ }+}++// Test mapLogLevelNames replaces only the LevelKey attr and lowercases it.+func TestMapLogLevelNames(t *testing.T) {+ a := slog.Any(slog.LevelKey, slog.LevelWarn)+ mapped := mapLogLevelNames(nil, a)+ val, ok := mapped.Value.Any().(string)+ if !ok || val != "warning" {+ t.Errorf("mapLogLevelNames did not lowercase level: got %v", mapped.Value.Any())+ }+ // non-level attr should remain unchanged+ other := slog.String("foo", "bar")+ out := mapLogLevelNames(nil, other)+ assert.Equal(t, out.Value, other.Value, "mapLogLevelNames changed a non-level attr")+}++// Test getCaller returns a file:line string of the correct form.+func TestGetCaller(t *testing.T) {+ out := getCaller(0)+ assert.NotEqual(t, "", out)+ match := regexp.MustCompile(`^([^:]+):(\d+)$`).FindStringSubmatch(out)+ assert.NotNil(t, match)+ // Can't test this as it skips the /log/ directory!+ // assert.Equal(t, "slog_test.go", match[1])+}++// Test formatStdLogHeader for various flag combinations.+func TestFormatStdLogHeader(t *testing.T) {+ cases := []struct {+ name string+ format logFormat+ lineInfo string+ object string+ wantPrefix string+ }{+ {"dateTime", logFormatDate | logFormatTime, "", "", "2020/01/02 03:04:05 "},+ {"time", logFormatTime, "", "", "03:04:05 "},+ {"date", logFormatDate, "", "", "2020/01/02 "},+ {"dateTimeUTC", logFormatDate | logFormatTime | logFormatUTC, "", "", "2020/01/02 02:04:05 "},+ {"dateTimeMicro", logFormatDate | logFormatTime | logFormatMicroseconds, "", "", "2020/01/02 03:04:05.123456 "},+ {"micro", logFormatMicroseconds, "", "", "03:04:05.123456 "},+ {"shortFile", logFormatShortFile, "foo.go:10", "03:04:05 ", "foo.go:10: "},+ {"longFile", logFormatLongFile, "foo.go:10", "03:04:05 ", "foo.go:10: "},+ {"timePID", logFormatPid, "", "", fmt.Sprintf("[%d] ", os.Getpid())},+ {"levelObject", 0, "", "myobj", "INFO : myobj: "},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ h := &OutputHandler{format: tc.format}+ buf := &bytes.Buffer{}+ h.formatStdLogHeader(buf, slog.LevelInfo, t0, tc.object, tc.lineInfo)+ if !strings.HasPrefix(buf.String(), tc.wantPrefix) {+ t.Errorf("%s: got %q; want prefix %q", tc.name, buf.String(), tc.wantPrefix)+ }+ })+ }+}++// Test Enabled honors the HandlerOptions.Level.+func TestEnabled(t *testing.T) {+ h := NewOutputHandler(&bytes.Buffer{}, nil, 0)+ assert.True(t, h.Enabled(context.Background(), slog.LevelInfo))+ assert.False(t, h.Enabled(context.Background(), slog.LevelDebug))++ opts := &slog.HandlerOptions{Level: slog.LevelDebug}+ h2 := NewOutputHandler(&bytes.Buffer{}, opts, 0)+ assert.True(t, h2.Enabled(context.Background(), slog.LevelDebug))+}++// Test clearFormatFlags and setFormatFlags bitwise ops.+func TestClearSetFormatFlags(t *testing.T) {+ h := &OutputHandler{format: logFormatDate | logFormatTime}++ h.clearFormatFlags(logFormatTime)+ assert.True(t, h.format&logFormatTime == 0)++ h.setFormatFlags(logFormatMicroseconds)+ assert.True(t, h.format&logFormatMicroseconds != 0)+}++// Test SetOutput and ResetOutput override the default writer.+func TestSetResetOutput(t *testing.T) {+ buf := &bytes.Buffer{}+ h := NewOutputHandler(buf, nil, 0)+ var gotOverride string+ out := func(_ slog.Level, txt string) {+ gotOverride = txt+ }++ h.SetOutput(out)+ r := slog.NewRecord(t0, slog.LevelInfo, "hello", 0)+ require.NoError(t, h.Handle(context.Background(), r))+ assert.NotEqual(t, "", gotOverride)+ require.Equal(t, "", buf.String())++ h.ResetOutput()+ require.NoError(t, h.Handle(context.Background(), r))+ require.NotEqual(t, "", buf.String())+}++// Test AddOutput sends to extra destinations.+func TestAddOutput(t *testing.T) {+ buf := &bytes.Buffer{}+ h := NewOutputHandler(buf, nil, logFormatDate|logFormatTime)+ var extraText string+ out := func(_ slog.Level, txt string) {+ extraText = txt+ }++ h.AddOutput(false, out)++ r := slog.NewRecord(t0, slog.LevelInfo, "world", 0)+ require.NoError(t, h.Handle(context.Background(), r))+ assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", buf.String())+ assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", extraText)+}++// Test AddOutputJSON sends JSON to extra destinations.+func TestAddOutputJSON(t *testing.T) {+ buf := &bytes.Buffer{}+ h := NewOutputHandler(buf, nil, logFormatDate|logFormatTime)+ var extraText string+ out := func(_ slog.Level, txt string) {+ extraText = txt+ }++ h.AddOutput(true, out)++ r := slog.NewRecord(t0, slog.LevelInfo, "world", 0)+ require.NoError(t, h.Handle(context.Background(), r))+ assert.NotEqual(t, "", extraText)+ assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", buf.String())+ assert.True(t, strings.HasPrefix(extraText, `{"time":"2020-01-02T03:04:05.123456+01:00","level":"info","msg":"world","source":"`))+ assert.True(t, strings.HasSuffix(extraText, "\"}\n"))+}++// Test AddOutputUseJSONLog sends text to extra destinations.+func TestAddOutputUseJSONLog(t *testing.T) {+ buf := &bytes.Buffer{}+ h := NewOutputHandler(buf, nil, logFormatDate|logFormatTime|logFormatJSON)+ var extraText string+ out := func(_ slog.Level, txt string) {+ extraText = txt+ }++ h.AddOutput(false, out)++ r := slog.NewRecord(t0, slog.LevelInfo, "world", 0)+ require.NoError(t, h.Handle(context.Background(), r))+ assert.NotEqual(t, "", extraText)+ assert.True(t, strings.HasPrefix(buf.String(), `{"time":"2020-01-02T03:04:05.123456+01:00","level":"info","msg":"world","source":"`))+ assert.True(t, strings.HasSuffix(buf.String(), "\"}\n"))+ assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", extraText)+}++// Test WithAttrs and WithGroup return new handlers with same settings.+func TestWithAttrsAndGroup(t *testing.T) {+ buf := &bytes.Buffer{}+ h := NewOutputHandler(buf, nil, logFormatDate)+ h2 := h.WithAttrs([]slog.Attr{slog.String("k", "v")})+ if _, ok := h2.(*OutputHandler); !ok {+ t.Error("WithAttrs returned wrong type")+ }+ h3 := h.WithGroup("grp")+ if _, ok := h3.(*OutputHandler); !ok {+ t.Error("WithGroup returned wrong type")+ }+}++// Test textLog and jsonLog directly for basic correctness.+func TestTextLogAndJsonLog(t *testing.T) {+ h := NewOutputHandler(&bytes.Buffer{}, nil, logFormatDate|logFormatTime)+ r := slog.NewRecord(t0, slog.LevelWarn, "msg!", 0)+ r.AddAttrs(slog.String("object", "obj"))++ // textLog+ bufText := &bytes.Buffer{}+ require.NoError(t, h.textLog(context.Background(), bufText, r))+ out := bufText.String()+ if !strings.Contains(out, "WARNING") || !strings.Contains(out, "obj:") || !strings.HasSuffix(out, "\n") {+ t.Errorf("textLog output = %q", out)+ }++ // jsonLog+ bufJSON := &bytes.Buffer{}+ require.NoError(t, h.jsonLog(context.Background(), bufJSON, r))+ j := bufJSON.String()+ if !strings.Contains(j, `"level":"warning"`) || !strings.Contains(j, `"msg":"msg!"`) {+ t.Errorf("jsonLog output = %q", j)+ }+}++// Table-driven test for JSON vs text Handle behavior.+func TestHandleFormatFlags(t *testing.T) {+ r := slog.NewRecord(t0, slog.LevelInfo, "hi", 0)+ cases := []struct {+ name string+ format logFormat+ wantJSON bool+ }{+ {"textMode", 0, false},+ {"jsonMode", logFormatJSON, true},+ }+ for _, tc := range cases {+ buf := &bytes.Buffer{}+ h := NewOutputHandler(buf, nil, tc.format)+ require.NoError(t, h.Handle(context.Background(), r))+ out := buf.String()+ if tc.wantJSON {+ if !strings.HasPrefix(out, "{") || !strings.Contains(out, `"level":"info"`) {+ t.Errorf("%s: got %q; want JSON", tc.name, out)+ }+ } else {+ if !strings.Contains(out, "INFO") {+ t.Errorf("%s: got %q; want text INFO", tc.name, out)+ }+ }+ }+}diff --git a/fs/log/syslog.go b/fs/log/syslog.goindex fd98f9fb6..f3ad7386e 100644--- a/fs/log/syslog.go+++ b/fs/log/syslog.go@@ -11,7 +11,7 @@ import ()// Starts syslog if configured, returns true if it was started-func startSysLog() bool {+func startSysLog(handler *OutputHandler) bool {fs.Fatalf(nil, "--syslog not supported on %s platform", runtime.GOOS)return false}diff --git a/fs/log/syslog_unix.go b/fs/log/syslog_unix.goindex 4fbbd2099..708083349 100644--- a/fs/log/syslog_unix.go+++ b/fs/log/syslog_unix.go@@ -5,7 +5,7 @@package logimport (- "log"+ "log/slog""log/syslog""os""path"@@ -39,7 +39,7 @@ var ()// Starts syslog-func startSysLog() bool {+func startSysLog(handler *OutputHandler) bool {facility, ok := syslogFacilityMap[Opt.SyslogFacility]if !ok {fs.Fatalf(nil, "Unknown syslog facility %q - man syslog for list", Opt.SyslogFacility)@@ -49,27 +49,27 @@ func startSysLog() bool {if err != nil {fs.Fatalf(nil, "Failed to start syslog: %v", err)}- log.SetFlags(0)- log.SetOutput(w)- fs.LogOutput = func(level fs.LogLevel, text string) {+ handler.clearFormatFlags(logFormatDate | logFormatTime | logFormatMicroseconds | logFormatUTC | logFormatLongFile | logFormatShortFile | logFormatPid)+ handler.setFormatFlags(logFormatNoLevel)+ handler.SetOutput(func(level slog.Level, text string) {switch level {- case fs.LogLevelEmergency:+ case fs.SlogLevelEmergency:_ = w.Emerg(text)- case fs.LogLevelAlert:+ case fs.SlogLevelAlert:_ = w.Alert(text)- case fs.LogLevelCritical:+ case fs.SlogLevelCritical:_ = w.Crit(text)- case fs.LogLevelError:+ case slog.LevelError:_ = w.Err(text)- case fs.LogLevelWarning:+ case slog.LevelWarn:_ = w.Warning(text)- case fs.LogLevelNotice:+ case fs.SlogLevelNotice:_ = w.Notice(text)- case fs.LogLevelInfo:+ case slog.LevelInfo:_ = w.Info(text)- case fs.LogLevelDebug:+ case slog.LevelDebug:_ = w.Debug(text)}- }+ })return true}diff --git a/fs/log/systemd.go b/fs/log/systemd.goindex 84e9a3bd3..8ebb2c0d9 100644--- a/fs/log/systemd.go+++ b/fs/log/systemd.go@@ -11,7 +11,7 @@ import ()// Enables systemd logs if configured or if auto-detected-func startSystemdLog() bool {+func startSystemdLog(handler *OutputHandler) bool {fs.Fatalf(nil, "--log-systemd not supported on %s platform", runtime.GOOS)return false}diff --git a/fs/log/systemd_unix.go b/fs/log/systemd_unix.goindex 22c82ad11..a71bc6880 100644--- a/fs/log/systemd_unix.go+++ b/fs/log/systemd_unix.go@@ -7,54 +7,47 @@ package logimport ("fmt""log"+ "log/slog""strconv"- "strings""github.com/coreos/go-systemd/v22/journal""github.com/rclone/rclone/fs")// Enables systemd logs if configured or if auto-detected-func startSystemdLog() bool {- flagsStr := "," + Opt.Format + ","- var flags int- if strings.Contains(flagsStr, ",longfile,") {- flags |= log.Llongfile- }- if strings.Contains(flagsStr, ",shortfile,") {- flags |= log.Lshortfile- }- log.SetFlags(flags)+func startSystemdLog(handler *OutputHandler) bool {+ handler.clearFormatFlags(logFormatDate | logFormatTime | logFormatMicroseconds | logFormatUTC | logFormatLongFile | logFormatShortFile | logFormatPid)+ handler.setFormatFlags(logFormatNoLevel)// TODO: Use the native journal.Print approach rather than a custom implementation- fs.LogOutput = func(level fs.LogLevel, text string) {+ handler.SetOutput(func(level slog.Level, text string) {text = fmt.Sprintf("<%s>%-6s: %s", systemdLogPrefix(level), level, text)_ = log.Output(4, text)- }+ })return true}-var logLevelToSystemdPrefix = []journal.Priority{- fs.LogLevelEmergency: journal.PriEmerg,- fs.LogLevelAlert: journal.PriAlert,- fs.LogLevelCritical: journal.PriCrit,- fs.LogLevelError: journal.PriErr,- fs.LogLevelWarning: journal.PriWarning,- fs.LogLevelNotice: journal.PriNotice,- fs.LogLevelInfo: journal.PriInfo,- fs.LogLevelDebug: journal.PriDebug,+var slogLevelToSystemdPrefix = map[slog.Level]journal.Priority{+ fs.SlogLevelEmergency: journal.PriEmerg,+ fs.SlogLevelAlert: journal.PriAlert,+ fs.SlogLevelCritical: journal.PriCrit,+ slog.LevelError: journal.PriErr,+ slog.LevelWarn: journal.PriWarning,+ fs.SlogLevelNotice: journal.PriNotice,+ slog.LevelInfo: journal.PriInfo,+ slog.LevelDebug: journal.PriDebug,}-func systemdLogPrefix(l fs.LogLevel) string {- if l >= fs.LogLevel(len(logLevelToSystemdPrefix)) {+func systemdLogPrefix(l slog.Level) string {+ prio, ok := slogLevelToSystemdPrefix[l]+ if !ok {return ""}- return strconv.Itoa(int(logLevelToSystemdPrefix[l]))+ return strconv.Itoa(int(prio))}func isJournalStream() bool {if usingJournald, _ := journal.StderrIsJournalStream(); usingJournald {return true}-return false}diff --git a/fs/operations/check_test.go b/fs/operations/check_test.goindex cf499dd96..eeffb0514 100644--- a/fs/operations/check_test.go+++ b/fs/operations/check_test.go@@ -6,12 +6,11 @@ import ("errors""fmt""io"- "log"- "os""sort""strings""testing"+ "github.com/rclone/rclone/cmd/bisync/bilib""github.com/rclone/rclone/fs""github.com/rclone/rclone/fs/accounting""github.com/rclone/rclone/fs/hash"@@ -65,18 +64,16 @@ func testCheck(t *testing.T, checkFunction func(ctx context.Context, opt *operatcheck := func(i int, wantErrors int64, wantChecks int64, oneway bool, wantOutput map[string]string) {t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {accounting.GlobalStats().ResetCounters()- var buf bytes.Buffer- log.SetOutput(&buf)- defer func() {- log.SetOutput(os.Stderr)- }()opt := operations.CheckOpt{Fdst: r.Fremote,Fsrc: r.Flocal,OneWay: oneway,}addBuffers(&opt)- err := checkFunction(ctx, &opt)+ var err error+ buf := bilib.CaptureOutput(func() {+ err = checkFunction(ctx, &opt)+ })gotErrors := accounting.GlobalStats().GetErrors()gotChecks := accounting.GlobalStats().GetChecks()if wantErrors == 0 && err != nil {@@ -88,7 +85,7 @@ func testCheck(t *testing.T, checkFunction func(ctx context.Context, opt *operatif wantErrors != gotErrors {t.Errorf("%d: Expecting %d errors but got %d", i, wantErrors, gotErrors)}- if gotChecks > 0 && !strings.Contains(buf.String(), "matching files") {+ if gotChecks > 0 && !strings.Contains(string(buf), "matching files") {t.Errorf("%d: Total files matching line missing", i)}if wantChecks != gotChecks {@@ -389,9 +386,6 @@ func testCheckSum(t *testing.T, download bool) {checkRun := func(runNo, wantChecks, wantErrors int, want wantType) {accounting.GlobalStats().ResetCounters()- buf := new(bytes.Buffer)- log.SetOutput(buf)- defer log.SetOutput(os.Stderr)opt := operations.CheckOpt{Combined: new(bytes.Buffer),@@ -401,8 +395,10 @@ func testCheckSum(t *testing.T, download bool) {MissingOnSrc: new(bytes.Buffer),MissingOnDst: new(bytes.Buffer),}- err := operations.CheckSum(ctx, dataFs, r.Fremote, sumFile, hashType, &opt, download)-+ var err error+ buf := bilib.CaptureOutput(func() {+ err = operations.CheckSum(ctx, dataFs, r.Fremote, sumFile, hashType, &opt, download)+ })gotErrors := int(accounting.GlobalStats().GetErrors())if wantErrors == 0 {assert.NoError(t, err, "unexpected error in run %d", runNo)@@ -414,7 +410,7 @@ func testCheckSum(t *testing.T, download bool) {gotChecks := int(accounting.GlobalStats().GetChecks())if wantChecks > 0 || gotChecks > 0 {- assert.Contains(t, buf.String(), "matching files", "missing matching files in run %d", runNo)+ assert.Contains(t, string(buf), "matching files", "missing matching files in run %d", runNo)}assert.Equal(t, wantChecks, gotChecks, "wrong number of checks in run %d", runNo)diff --git a/go.mod b/go.modindex 8e62e7ea5..b05d93171 100644--- a/go.mod+++ b/go.mod@@ -66,7 +66,6 @@ require (github.com/rivo/uniseg v0.4.7github.com/rogpeppe/go-internal v1.14.1github.com/shirou/gopsutil/v4 v4.25.1- github.com/sirupsen/logrus v1.9.3github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966github.com/spf13/cobra v1.9.1github.com/spf13/pflag v1.0.6@@ -208,6 +207,7 @@ require (github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirectgithub.com/samber/lo v1.47.0 // indirectgithub.com/shabbyrobe/gocovmerge v0.0.0-20230507112040-c3350d9342df // indirect+ github.com/sirupsen/logrus v1.9.3 // indirectgithub.com/sony/gobreaker v0.5.0 // indirectgithub.com/spacemonkeygo/monkit/v3 v3.0.22 // indirectgithub.com/tklauser/go-sysconf v0.3.13 // indirect