Log file management and cleanup

[t3therdev]

Which version are you using?

v0.15.0

Enhancement request

Would it be possible to add a feature to set the max log file size? The issue is that if the log gets too big over time it could fill up the drive.

Possibly 2 settings:

1. max log file size (size before it breaks into another file, 50MB for example)
2. total log max (total of all logs, for example 200MB) , deletion of oldest logs after max size is met, FIFO.

[aler9]

Log rotation and cleanup is handled externally in every server software, from Nginx to Redis.

There's logrotate for Unix, there are plenty of equivalents for Windows.

Just remember to use the copytruncate option, otherwise the server will keep writing to the old log file.

[t3therdev]

The problem is on windows the log file is in use (and locked) by the server executable. We don't want to have to close the server to move/copy or delete the file. How do you suggest we handle this on windows?

[aler9]

Hello, i checked the Windows implementation, and is true that rtsp-simple-server locks the log files. This is the default behavior offered by Golang. There is surely a way to avoid this, since other servers for Windows allows to move / delete log files.

I need to investigate further.

[aler9]

How do you suggest we handle this on windows?

i investigated deeper; while it's not possible to move or delete the file, it's possible to copy it on another location and truncate it (like i suggested before, the copytruncate option). You can copy and truncate the log file with a really simple script like this one:

logrotator.zip

package main

import (
	"os"
	"io/ioutil"
	"strconv"
)

var logfile = "rtsp-simple-server.log"

func copyFile(source, dest string) error {
	byts, err := ioutil.ReadFile(source)
	if err != nil {
			return err
	}

	return ioutil.WriteFile(dest, byts, 0644)
}

func main() {
	i := 1
	for {
		_, err := os.Stat(logfile+"."+strconv.FormatInt(int64(i), 10))
		if err != nil {
			break
		}
		i++
	}

	for j := i-1; j >= 1; j-- {
		err := os.Rename(logfile+"."+strconv.FormatInt(int64(j), 10), logfile+"."+strconv.FormatInt(int64(j+1), 10))
		if err != nil {
			panic(err)
		}
	}

	err := copyFile(logfile, logfile+".1")
	if err != nil {
		panic(err)
	}

	err = os.Truncate(logfile, 0)
	if err != nil {
		panic(err)
	}
}

(PS: On Windows, it's possible to write to files without locking them, but in this way the server would write logs to the moved/deleted file, and not to a newer one, therefore it's better not to enable this feature)