rollingwriter: github.com/arthurkiller/rollingwriter Index | Files | Directories

package rollingwriter

import "github.com/arthurkiller/rollingwriter"

Index

Package Files

manager.go rollingwriter.go writer.go

Constants

const (
    WithoutRolling = iota
    TimeRolling
    VolumeRolling
)

RollingPolicies giveout 3 policy for rolling.

Variables

var (
    // BufferSize defined the buffer size, by default 1M buffer will be allocate
    BufferSize = 0x100000
    // QueueSize defined the queue size for asynchronize write
    QueueSize = 1024
    // Precision defined the precision about the reopen operation condition
    // check duration within second
    Precision = 1
    // DefaultFileMode set the default open mode rw-r--r-- by default
    DefaultFileMode = os.FileMode(0644)
    // DefaultFileFlag set the default file flag
    DefaultFileFlag = os.O_RDWR | os.O_CREATE | os.O_APPEND

    // ErrInternal defined the internal error
    ErrInternal = errors.New("error internal")
    // ErrClosed defined write while ctx close
    ErrClosed = errors.New("error write on close")
    // ErrInvalidArgument defined the invalid argument
    ErrInvalidArgument = errors.New("error argument invalid")
)

func AsynchronousWriterErrorChan Uses

func AsynchronousWriterErrorChan(wr RollingWriter) (chan error, error)

AsynchronousWriterErrorChan return the error channel for asyn writer

func LogFilePath Uses

func LogFilePath(c *Config) (filepath string)

LogFilePath return the absolute path on log file

type AsynchronousWriter Uses

type AsynchronousWriter struct {
    Writer
    // contains filtered or unexported fields
}

AsynchronousWriter provide a asynchronous writer with the writer to confirm the write

func (*AsynchronousWriter) Close Uses

func (w *AsynchronousWriter) Close() error

Close set closed and close the file once

func (*AsynchronousWriter) Write Uses

func (w *AsynchronousWriter) Write(b []byte) (int, error)

Only when the error channel is empty, otherwise nothing will write and the last error will be return return the error channel

type BufferWriter Uses

type BufferWriter struct {
    Writer
    // contains filtered or unexported fields
}

BufferWriter merge some write operations into one.

func (*BufferWriter) Close Uses

func (w *BufferWriter) Close() error

Close bufferWriter flush all buffered write then close file

func (*BufferWriter) Write Uses

func (w *BufferWriter) Write(b []byte) (int, error)

type Config Uses

type Config struct {
    // LogPath defined the full path of log file directory.
    // there comes out 2 different log file:
    //
    // 1. the current log
    //	log file path is located here:
    //	[LogPath]/[FileName].log
    //
    // 2. the tuncated log file
    //	the tuncated log file is backup here:
    //	[LogPath]/[FileName].log.[TimeTag]
    //  if compressed true
    //	[LogPath]/[FileName].log.gz.[TimeTag]
    //
    // NOTICE: blank field will be ignored
    // By default we using '-' as separator, you can set it yourself
    TimeTagFormat string `json:"time_tag_format"`
    LogPath       string `json:"log_path"`
    FileName      string `json:"file_name"`
    // MaxRemain will auto clear the roling file list, set 0 will disable auto clean
    MaxRemain int `json:"max_remain"`

    // RollingPolicy give out the rolling policy
    // We got 3 policies(actually, 2):
    //
    //	1. WithoutRolling: no rolling will happen
    //	2. TimeRolling: rolling by time
    //	3. VolumeRolling: rolling by file size
    RollingPolicy      int    `json:"rolling_ploicy"`
    RollingTimePattern string `json:"rolling_time_pattern"`
    RollingVolumeSize  string `json:"rolling_volume_size"`

    // WriterMode in 4 modes below
    // 1. none 2. lock
    // 3. async 4. buffer
    WriterMode string `json:"writer_mode"`
    // BufferWriterThershould in Byte
    BufferWriterThershould int `json:"buffer_thershould"`
    // Compress will compress log file with gzip
    Compress bool `json:"compress"`
}

Config give out the config for manager

func NewDefaultConfig Uses

func NewDefaultConfig() Config

NewDefaultConfig return the default config

type LockedWriter Uses

type LockedWriter struct {
    Writer
    sync.Mutex
}

LockedWriter provide a synchronous writer with lock write operate will be guaranteed by lock

func (*LockedWriter) Close Uses

func (w *LockedWriter) Close() error

Close lock and close the file

func (*LockedWriter) Write Uses

func (w *LockedWriter) Write(b []byte) (n int, err error)

type Manager Uses

type Manager interface {
    // Fire will return a string channel
    // while the rolling event occoured, new file name will generate
    Fire() chan string
    // Close the Manager
    Close()
}

Manager used to trigger rolling event.

func NewManager Uses

func NewManager(c *Config) (Manager, error)

NewManager generate the Manager with config

type Option Uses

type Option func(*Config)

Option defined config option

func WithAsynchronous Uses

func WithAsynchronous() Option

WithAsynchronous enable the asynchronous write for writer

func WithBuffer Uses

func WithBuffer() Option

WithBuffer will enable the buffer writer mode

func WithBufferThershould Uses

func WithBufferThershould(n int) Option

WithBufferThershould set buffer write thershould

func WithCompress Uses

func WithCompress() Option

WithCompress will auto compress the tuncated log file with gzip

func WithFileName Uses

func WithFileName(name string) Option

WithFileName set the log file name

func WithLock Uses

func WithLock() Option

WithLock will enable the lock in writer Writer will call write with the Lock to guarantee the parallel safe

func WithLogPath Uses

func WithLogPath(path string) Option

WithLogPath set the log dir and auto create dir tree if the dir/path is not exist

func WithMaxRemain Uses

func WithMaxRemain(max int) Option

WithMaxRemain enable the auto deletion for old file when exceed the given max value Bydefault -1 will disable the auto deletion

func WithRollingTimePattern Uses

func WithRollingTimePattern(pattern string) Option

WithRollingTimePattern set the time rolling policy time pattern obey the Corn table style visit http://crontab.org/ for details

func WithRollingVolumeSize Uses

func WithRollingVolumeSize(size string) Option

WithRollingVolumeSize set the rolling file truncation threshold size

func WithTimeTagFormat Uses

func WithTimeTagFormat(format string) Option

WithTimeTagFormat set the TimeTag format string

func WithoutRollingPolicy Uses

func WithoutRollingPolicy() Option

WithoutRolling set no rolling policy

type RollingWriter Uses

type RollingWriter interface {
    io.Writer
    Close() error
}

RollingWriter implement the io writer

func NewWriter Uses

func NewWriter(ops ...Option) (RollingWriter, error)

NewWriter generate the rollingWriter with given option

func NewWriterFromConfig Uses

func NewWriterFromConfig(c *Config) (RollingWriter, error)

NewWriterFromConfig generate the rollingWriter with given config

func NewWriterFromConfigFile Uses

func NewWriterFromConfigFile(path string) (RollingWriter, error)

NewWriterFromConfigFile generate the rollingWriter with given config file

type Writer Uses

type Writer struct {
    // contains filtered or unexported fields
}

Writer provide a synchronous file writer if Lock is set true, write will be guaranteed by lock

func (*Writer) Close Uses

func (w *Writer) Close() error

Close the file and return

func (*Writer) CompressFile Uses

func (w *Writer) CompressFile(oldfile *os.File, cmpname string) error

CompressFile compress log file write into .gz and remove source file

func (*Writer) DoRemove Uses

func (w *Writer) DoRemove()

DoRemove will delete the oldest file

func (*Writer) Reopen Uses

func (w *Writer) Reopen(file string) error

Reopen do the rotate, open new file and swap FD then trate the old FD

func (*Writer) Write Uses

func (w *Writer) Write(b []byte) (int, error)

Directories

PathSynopsis
demo

Package rollingwriter imports 16 packages (graph) and is imported by 2 packages. Updated 2020-03-05. Refresh now. Tools for package owners.