Makes a standard os.File a "reopenable writer" and allows SIGHUP signals to reopen log files, as needed by logrotated. This is inspired by the C/Posix freopen

The simple version reopen.NewFileWriter does unbuffered writing. A call to .Reopen closes the existing file handle, and then re-opens it using the original filename.

The more advanced version reopen.NewBufferedFileWriter buffers input and flushes when the internal buffer is full (with care) or if 30 seconds has elapsed.

There is also reopen.Stderr and reopen.Stdout which implements the reopen.Reopener interface (and does nothing on a reopen call).

reopen.Discard wraps ioutil.Discard

Samples are in example1 and example2. The run.sh scripts are a dumb test where the file is rotated underneath the server, and nothing is lost. This is not the most robust test but gives you an idea of how it works.

Here's some sample code.

package main

/* Simple logrotate logger
 */
import (
       "fmt"
       "log"
       "net/http"
       "os"
       "os/signal"
       "syscall"

       "github.com/client9/reopen"
)

func main() {
        // setup logger to write to our new *reopenable* log file

        f, err := reopen.NewFileWriter("/tmp/example.log")
        if err != nil {
           log.Fatalf("Unable to set output log: %s", err)
        }
        log.SetOutput(f)

        // Handle SIGHUP
        //
        // channel is number of signals needed to catch  (more or less)
        // we only are working with one here, SIGHUP
        sighup := make(chan os.Signal, 1)
        signal.Notify(sighup, syscall.SIGHUP)
        go func() {
           for {
               <-sighup
              fmt.Println("Got a sighup")
              f.Reopen()
            }
         }()

        // dumb http server that just prints and logs the path
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
            log.Printf("%s", r.URL.Path)
            fmt.Fprintf(w, "%s\n", r.URL.Path)
        })
        log.Fatal(http.ListenAndServe("127.0.0.1:8123", nil))
}