Documentation

Overview

    Package logging enables setting custom logger implementation.

    Basic Flow:
    1) Initialize logger
    2) Create new logger for specific module
    3) Call log info
    
    Example
    Output:
    
    log info is completed
    

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func Initialize

    func Initialize(l api.LoggerProvider)

      Initialize sets new logger which takes over logging operations. It is required to call this function before making any loggings.

      Example
      Output:
      
      log is completed
      

      func IsEnabledFor

      func IsEnabledFor(module string, level Level) bool

        IsEnabledFor - Check if given log level is enabled for given module

        Parameters:
        module is module name
        level is logging level
        
        Returns:
        is logging enabled for this module and level
        
        Example
        Output:
        
        log is completed
        

        func SetLevel

        func SetLevel(module string, level Level)

          SetLevel - setting log level for given module

          Parameters:
          module is module name
          level is logging level
          
          Example
          Output:
          
          log is completed
          

          Types

          type Level

          type Level int

            Level defines all available log levels for log messages.

            const (
            	CRITICAL Level = iota
            	ERROR
            	WARNING
            	INFO
            	DEBUG
            )

              Log levels.

              func GetLevel

              func GetLevel(module string) Level

                GetLevel - getting log level for given module

                Parameters:
                module is module name
                
                Returns:
                logging level
                
                Example
                Output:
                
                log is completed
                

                func LogLevel

                func LogLevel(level string) (Level, error)

                  LogLevel returns the log level from a string representation.

                  Parameters:
                  level is logging level in string representation
                  
                  Returns:
                  logging level
                  
                  Example
                  Output:
                  
                  log is completed
                  

                  type Logger

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

                    Logger basic implementation of api.Logger interface

                    func NewLogger

                    func NewLogger(module string) *Logger

                      NewLogger creates and returns a Logger object based on the module name.

                      Example
                      Output:
                      
                      log is completed
                      

                      func (*Logger) Debug

                      func (l *Logger) Debug(args ...interface{})

                        Debug calls Debug function of underlying logger

                        func (*Logger) Debugf

                        func (l *Logger) Debugf(format string, args ...interface{})

                          Debugf calls Debugf function of underlying logger

                          func (*Logger) Debugln

                          func (l *Logger) Debugln(args ...interface{})

                            Debugln calls Debugln function of underlying logger

                            func (*Logger) Error

                            func (l *Logger) Error(args ...interface{})

                              Error calls Error function of underlying logger

                              func (*Logger) Errorf

                              func (l *Logger) Errorf(format string, args ...interface{})

                                Errorf calls Errorf function of underlying logger

                                func (*Logger) Errorln

                                func (l *Logger) Errorln(args ...interface{})

                                  Errorln calls Errorln function of underlying logger

                                  func (*Logger) Fatal

                                  func (l *Logger) Fatal(args ...interface{})

                                    Fatal calls Fatal function of underlying logger

                                    func (*Logger) Fatalf

                                    func (l *Logger) Fatalf(format string, args ...interface{})

                                      Fatalf calls Fatalf function of underlying logger

                                      func (*Logger) Fatalln

                                      func (l *Logger) Fatalln(args ...interface{})

                                        Fatalln calls Fatalln function of underlying logger

                                        func (*Logger) Info

                                        func (l *Logger) Info(args ...interface{})

                                          Info calls Info function of underlying logger

                                          func (*Logger) Infof

                                          func (l *Logger) Infof(format string, args ...interface{})

                                            Infof calls Infof function of underlying logger

                                            func (*Logger) Infoln

                                            func (l *Logger) Infoln(args ...interface{})

                                              Infoln calls Infoln function of underlying logger

                                              func (*Logger) Panic

                                              func (l *Logger) Panic(args ...interface{})

                                                Panic calls Panic function of underlying logger

                                                func (*Logger) Panicf

                                                func (l *Logger) Panicf(format string, args ...interface{})

                                                  Panicf calls Panicf function of underlying logger

                                                  func (*Logger) Panicln

                                                  func (l *Logger) Panicln(args ...interface{})

                                                    Panicln calls Panicln function of underlying logger

                                                    func (*Logger) Print

                                                    func (l *Logger) Print(args ...interface{})

                                                      Print calls Print function of underlying logger

                                                      func (*Logger) Printf

                                                      func (l *Logger) Printf(format string, args ...interface{})

                                                        Printf calls Printf function of underlying logger

                                                        func (*Logger) Println

                                                        func (l *Logger) Println(args ...interface{})

                                                          Println calls Println function of underlying logger

                                                          func (*Logger) Warn

                                                          func (l *Logger) Warn(args ...interface{})

                                                            Warn calls Warn function of underlying logger

                                                            func (*Logger) Warnf

                                                            func (l *Logger) Warnf(format string, args ...interface{})

                                                              Warnf calls Warnf function of underlying logger

                                                              func (*Logger) Warnln

                                                              func (l *Logger) Warnln(args ...interface{})

                                                                Warnln calls Warnln function of underlying logger

                                                                Source Files