...

Source file src/gitlab.com/tymonx/go-logger/logger/file.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  	"io"
    19  	"os"
    20  )
    21  
    22  // These constants define default values for File log handler.
    23  const (
    24  	DefaultFileName  = "log"
    25  	DefaultFileMode  = 0644
    26  	DefaultFileFlags = os.O_CREATE | os.O_APPEND | os.O_WRONLY
    27  )
    28  
    29  // A File represents a log handler object for logging messages to file.
    30  type File struct {
    31  	name   string
    32  	stream *Stream
    33  	flags  int
    34  	mode   os.FileMode
    35  }
    36  
    37  // NewFile creates a new File log handler object.
    38  func NewFile() *File {
    39  	f := &File{
    40  		name:   DefaultFileName,
    41  		mode:   DefaultFileMode,
    42  		flags:  DefaultFileFlags,
    43  		stream: NewStream(),
    44  	}
    45  
    46  	f.stream.SetOpener(f)
    47  
    48  	return f
    49  }
    50  
    51  // SetStreamHandler sets custom stream handler.
    52  func (f *File) SetStreamHandler(handler StreamHandler) *File {
    53  	f.stream.SetStreamHandler(handler)
    54  	return f
    55  }
    56  
    57  // Open file.
    58  func (f *File) Open() (io.WriteCloser, error) {
    59  	return os.OpenFile(f.name, f.flags, f.mode)
    60  }
    61  
    62  // Enable enables log handler.
    63  func (f *File) Enable() Handler {
    64  	return f.stream.Enable()
    65  }
    66  
    67  // Disable disabled log handler.
    68  func (f *File) Disable() Handler {
    69  	return f.stream.Disable()
    70  }
    71  
    72  // IsEnabled returns if log handler is enabled.
    73  func (f *File) IsEnabled() bool {
    74  	return f.stream.IsEnabled()
    75  }
    76  
    77  // SetFormatter sets Formatter.
    78  func (f *File) SetFormatter(formatter *Formatter) Handler {
    79  	return f.stream.SetFormatter(formatter)
    80  }
    81  
    82  // GetFormatter returns Formatter.
    83  func (f *File) GetFormatter() *Formatter {
    84  	return f.stream.GetFormatter()
    85  }
    86  
    87  // SetLevel sets log level.
    88  func (f *File) SetLevel(level int) Handler {
    89  	return f.stream.SetLevel(level)
    90  }
    91  
    92  // SetMinimumLevel sets minimum log level.
    93  func (f *File) SetMinimumLevel(level int) Handler {
    94  	return f.stream.SetMinimumLevel(level)
    95  }
    96  
    97  // GetMinimumLevel returns minimum log level.
    98  func (f *File) GetMinimumLevel() int {
    99  	return f.stream.GetMinimumLevel()
   100  }
   101  
   102  // SetMaximumLevel sets maximum log level.
   103  func (f *File) SetMaximumLevel(level int) Handler {
   104  	return f.stream.SetMaximumLevel(level)
   105  }
   106  
   107  // GetMaximumLevel returns maximum log level.
   108  func (f *File) GetMaximumLevel() int {
   109  	return f.stream.GetMaximumLevel()
   110  }
   111  
   112  // SetLevelRange sets minimum and maximum log level values.
   113  func (f *File) SetLevelRange(min, max int) Handler {
   114  	return f.stream.SetLevelRange(min, max)
   115  }
   116  
   117  // GetLevelRange returns minimum and maximum log level values.
   118  func (f *File) GetLevelRange() (min, max int) {
   119  	return f.stream.GetLevelRange()
   120  }
   121  
   122  // SetName sets file name used for log messages.
   123  func (f *File) SetName(name string) *File {
   124  	f.stream.Lock()
   125  	defer f.stream.Unlock()
   126  
   127  	if f.name != name {
   128  		f.name = name
   129  		f.stream.Reopen()
   130  	}
   131  
   132  	return f
   133  }
   134  
   135  // GetName sets file name used for log messages.
   136  func (f *File) GetName() string {
   137  	f.stream.RLock()
   138  	defer f.stream.RUnlock()
   139  
   140  	return f.name
   141  }
   142  
   143  // SetFlags sets file flags from os package.
   144  func (f *File) SetFlags(flags int) *File {
   145  	f.stream.Lock()
   146  	defer f.stream.Unlock()
   147  
   148  	if f.flags != flags {
   149  		f.flags = flags
   150  		f.stream.Reopen()
   151  	}
   152  
   153  	return f
   154  }
   155  
   156  // GetFlags returns file flags.
   157  func (f *File) GetFlags() int {
   158  	f.stream.RLock()
   159  	defer f.stream.RUnlock()
   160  
   161  	return f.flags
   162  }
   163  
   164  // SetMode sets file mode/permissions.
   165  func (f *File) SetMode(mode os.FileMode) *File {
   166  	f.stream.Lock()
   167  	defer f.stream.Unlock()
   168  
   169  	if f.mode != mode {
   170  		f.mode = mode
   171  		f.stream.Reopen()
   172  	}
   173  
   174  	return f
   175  }
   176  
   177  // GetMode returns file mode/permissions.
   178  func (f *File) GetMode() os.FileMode {
   179  	f.stream.RLock()
   180  	defer f.stream.RUnlock()
   181  
   182  	return f.mode
   183  }
   184  
   185  // Emit logs messages from Logger to file.
   186  func (f *File) Emit(record *Record) error {
   187  	return f.stream.Emit(record)
   188  }
   189  
   190  // Close closes opened file.
   191  func (f *File) Close() error {
   192  	return f.stream.Close()
   193  }
   194  

View as plain text