writer.go

Documentation: github.com/sirupsen/logrus

     1  package logrus
     2  
     3  import (
     4  	"bufio"
     5  	"io"
     6  	"runtime"
     7  	"strings"
     8  )
     9  
    10  // Writer at INFO level. See WriterLevel for details.
    11  func (logger *Logger) Writer() *io.PipeWriter {
    12  	return logger.WriterLevel(InfoLevel)
    13  }
    14  
    15  // WriterLevel returns an io.Writer that can be used to write arbitrary text to
    16  // the logger at the given log level. Each line written to the writer will be
    17  // printed in the usual way using formatters and hooks. The writer is part of an
    18  // io.Pipe and it is the callers responsibility to close the writer when done.
    19  // This can be used to override the standard library logger easily.
    20  func (logger *Logger) WriterLevel(level Level) *io.PipeWriter {
    21  	return NewEntry(logger).WriterLevel(level)
    22  }
    23  
    24  // Writer returns an io.Writer that writes to the logger at the info log level
    25  func (entry *Entry) Writer() *io.PipeWriter {
    26  	return entry.WriterLevel(InfoLevel)
    27  }
    28  
    29  // WriterLevel returns an io.Writer that writes to the logger at the given log level
    30  func (entry *Entry) WriterLevel(level Level) *io.PipeWriter {
    31  	reader, writer := io.Pipe()
    32  
    33  	var printFunc func(args ...interface{})
    34  
    35  	// Determine which log function to use based on the specified log level
    36  	switch level {
    37  	case TraceLevel:
    38  		printFunc = entry.Trace
    39  	case DebugLevel:
    40  		printFunc = entry.Debug
    41  	case InfoLevel:
    42  		printFunc = entry.Info
    43  	case WarnLevel:
    44  		printFunc = entry.Warn
    45  	case ErrorLevel:
    46  		printFunc = entry.Error
    47  	case FatalLevel:
    48  		printFunc = entry.Fatal
    49  	case PanicLevel:
    50  		printFunc = entry.Panic
    51  	default:
    52  		printFunc = entry.Print
    53  	}
    54  
    55  	// Start a new goroutine to scan the input and write it to the logger using the specified print function.
    56  	// It splits the input into chunks of up to 64KB to avoid buffer overflows.
    57  	go entry.writerScanner(reader, printFunc)
    58  
    59  	// Set a finalizer function to close the writer when it is garbage collected
    60  	runtime.SetFinalizer(writer, writerFinalizer)
    61  
    62  	return writer
    63  }
    64  
    65  // writerScanner scans the input from the reader and writes it to the logger
    66  func (entry *Entry) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) {
    67  	scanner := bufio.NewScanner(reader)
    68  
    69  	// Set the buffer size to the maximum token size to avoid buffer overflows
    70  	scanner.Buffer(make([]byte, bufio.MaxScanTokenSize), bufio.MaxScanTokenSize)
    71  
    72  	// Define a split function to split the input into chunks of up to 64KB
    73  	chunkSize := bufio.MaxScanTokenSize // 64KB
    74  	splitFunc := func(data []byte, atEOF bool) (int, []byte, error) {
    75  		if len(data) >= chunkSize {
    76  			return chunkSize, data[:chunkSize], nil
    77  		}
    78  
    79  		return bufio.ScanLines(data, atEOF)
    80  	}
    81  
    82  	// Use the custom split function to split the input
    83  	scanner.Split(splitFunc)
    84  
    85  	// Scan the input and write it to the logger using the specified print function
    86  	for scanner.Scan() {
    87  		printFunc(strings.TrimRight(scanner.Text(), "\r\n"))
    88  	}
    89  
    90  	// If there was an error while scanning the input, log an error
    91  	if err := scanner.Err(); err != nil {
    92  		entry.Errorf("Error while reading from Writer: %s", err)
    93  	}
    94  
    95  	// Close the reader when we are done
    96  	reader.Close()
    97  }
    98  
    99  // WriterFinalizer is a finalizer function that closes then given writer when it is garbage collected
   100  func writerFinalizer(writer *io.PipeWriter) {
   101  	writer.Close()
   102  }
   103
View as plain text