...

Source file src/gitlab.com/tymonx/go-logger/logger/buffer.go

Documentation: gitlab.com/tymonx/go-logger/logger

     1  // Copyright 2020 Tymoteusz Blazejczyk
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package logger
    16  
    17  import (
    18  	"bytes"
    19  )
    20  
    21  // A Buffer represents a log handler object for logging messages using buffer
    22  // object.
    23  type Buffer struct {
    24  	buffer bytes.Buffer
    25  	stream *Stream
    26  }
    27  
    28  // NewBuffer creates a new buffer log handler object.
    29  func NewBuffer() *Buffer {
    30  	b := &Buffer{
    31  		stream: NewStream(),
    32  	}
    33  
    34  	b.stream.writer = &b.buffer
    35  
    36  	return b
    37  }
    38  
    39  // SetStreamHandler sets custom stream handler.
    40  func (b *Buffer) SetStreamHandler(handler StreamHandler) *Buffer {
    41  	b.stream.SetStreamHandler(handler)
    42  	return b
    43  }
    44  
    45  // GetBuffer returns internal buffer object.
    46  func (b *Buffer) GetBuffer() *bytes.Buffer {
    47  	b.stream.RLock()
    48  	defer b.stream.RUnlock()
    49  
    50  	return &b.buffer
    51  }
    52  
    53  // Length returns the number of bytes of the unread portion of the buffer.
    54  func (b *Buffer) Length() int {
    55  	b.stream.RLock()
    56  	defer b.stream.RUnlock()
    57  
    58  	return b.buffer.Len()
    59  }
    60  
    61  // String returns the contents of the unread portion of the buffer as a string.
    62  func (b *Buffer) String() string {
    63  	b.stream.RLock()
    64  	defer b.stream.RUnlock()
    65  
    66  	return b.buffer.String()
    67  }
    68  
    69  // Bytes returns a slice of length b.Length() holding the unread portion of
    70  // the buffer. The slice is valid for use only until the next buffer
    71  // modification.
    72  func (b *Buffer) Bytes() []byte {
    73  	b.stream.RLock()
    74  	defer b.stream.RUnlock()
    75  
    76  	return b.buffer.Bytes()
    77  }
    78  
    79  // Reset resets the buffer to be empty, but it retains the underlying storage for use by future writes.
    80  func (b *Buffer) Reset() {
    81  	b.stream.Lock()
    82  	defer b.stream.Unlock()
    83  
    84  	b.buffer.Reset()
    85  }
    86  
    87  // Enable enables log handler.
    88  func (b *Buffer) Enable() Handler {
    89  	return b.stream.Enable()
    90  }
    91  
    92  // Disable disabled log handler.
    93  func (b *Buffer) Disable() Handler {
    94  	return b.stream.Disable()
    95  }
    96  
    97  // IsEnabled returns if log handler is enabled.
    98  func (b *Buffer) IsEnabled() bool {
    99  	return b.stream.IsEnabled()
   100  }
   101  
   102  // SetFormatter sets log formatter.
   103  func (b *Buffer) SetFormatter(formatter *Formatter) Handler {
   104  	return b.stream.SetFormatter(formatter)
   105  }
   106  
   107  // GetFormatter returns log formatter.
   108  func (b *Buffer) GetFormatter() *Formatter {
   109  	return b.stream.GetFormatter()
   110  }
   111  
   112  // SetLevel sets log level.
   113  func (b *Buffer) SetLevel(level int) Handler {
   114  	return b.stream.SetLevel(level)
   115  }
   116  
   117  // SetMinimumLevel sets minimum log level.
   118  func (b *Buffer) SetMinimumLevel(level int) Handler {
   119  	return b.stream.SetMinimumLevel(level)
   120  }
   121  
   122  // GetMinimumLevel returns minimum log level.
   123  func (b *Buffer) GetMinimumLevel() int {
   124  	return b.stream.GetMinimumLevel()
   125  }
   126  
   127  // SetMaximumLevel sets maximum log level.
   128  func (b *Buffer) SetMaximumLevel(level int) Handler {
   129  	return b.stream.SetMaximumLevel(level)
   130  }
   131  
   132  // GetMaximumLevel returns maximum log level.
   133  func (b *Buffer) GetMaximumLevel() int {
   134  	return b.stream.GetMaximumLevel()
   135  }
   136  
   137  // SetLevelRange sets minimum and maximum log level values.
   138  func (b *Buffer) SetLevelRange(min, max int) Handler {
   139  	return b.stream.SetLevelRange(min, max)
   140  }
   141  
   142  // GetLevelRange returns minimum and maximum log level values.
   143  func (b *Buffer) GetLevelRange() (min, max int) {
   144  	return b.stream.GetLevelRange()
   145  }
   146  
   147  // Emit logs messages from logger using buffer.
   148  func (b *Buffer) Emit(record *Record) error {
   149  	return b.stream.Emit(record)
   150  }
   151  
   152  // Close closes buffer.
   153  func (b *Buffer) Close() error {
   154  	return b.stream.Close()
   155  }
   156  

View as plain text