github.com/banzaicloud/operator-tools@v0.28.10/pkg/logger/logger.go (about)

     1  // Copyright © 2020 Banzai Cloud
     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  	"fmt"
    19  
    20  	"github.com/go-logr/logr"
    21  )
    22  
    23  var (
    24  	GlobalLogLevel = 1
    25  
    26  	Log = New()
    27  )
    28  
    29  type GroupedLogger interface {
    30  	Grouped(state bool)
    31  }
    32  
    33  type Logger interface {
    34  	Enabled() bool
    35  	Info(msg string, keysAndValues ...interface{})
    36  	Error(err error, msg string, keysAndValues ...interface{})
    37  	V(level int) Logger
    38  	WithValues(keysAndValues ...interface{}) Logger
    39  	WithName(name string) Logger
    40  
    41  	GetLogrLogger() logr.Logger
    42  }
    43  
    44  type logger struct {
    45  	level int
    46  	sink  *SpinnerLogSink
    47  }
    48  
    49  func New(options ...Option) Logger {
    50  	sink := NewSpinnerLogSink(options...)
    51  	return &logger{
    52  		level: 0,
    53  		sink:  sink,
    54  	}
    55  }
    56  
    57  func (log *logger) Info(msg string, keysAndValues ...interface{}) {
    58  	log.sink.Info(log.level, msg, keysAndValues)
    59  }
    60  
    61  func (log *logger) Enabled() bool {
    62  	return log.sink.Enabled(log.level)
    63  }
    64  
    65  func (log *logger) Error(e error, msg string, keysAndValues ...interface{}) {
    66  	log.sink.Error(e, msg, keysAndValues)
    67  }
    68  
    69  func (log *logger) V(level int) Logger {
    70  	return &logger{
    71  		level: level,
    72  		sink:  log.sink.copyLogger(),
    73  	}
    74  }
    75  
    76  func (log *logger) WithName(name string) Logger {
    77  	sink := log.sink.copyLogger()
    78  	sink.names = append(sink.names, name)
    79  
    80  	return &logger{
    81  		level: log.level,
    82  		sink:  sink,
    83  	}
    84  }
    85  
    86  func (log *logger) WithValues(keysAndValues ...interface{}) Logger {
    87  	sink := log.sink.copyLogger()
    88  
    89  	sink.values = keysAndValues
    90  
    91  	return &logger{
    92  		level: log.level,
    93  		sink:  sink,
    94  	}
    95  }
    96  
    97  func (log *logger) GetLogrLogger() logr.Logger {
    98  	sink := log.sink.copyLogger()
    99  	return logr.New(sink).V(log.level)
   100  }
   101  
   102  func (log *logger) Plain(msg string) {
   103  	if GlobalLogLevel >= log.level {
   104  		fmt.Println(fmt.Sprint(msg))
   105  	}
   106  }
   107  
   108  func (log *logger) Plainf(format string, args ...interface{}) {
   109  	if GlobalLogLevel >= log.level {
   110  		fmt.Println(fmt.Sprintf(format, args...))
   111  	}
   112  }
   113  
   114  func (log *logger) SetOptions(options ...Option) {
   115  	log.sink.SetOptions(options...)
   116  }
   117  
   118  func (log *logger) ShowTime(f bool) Logger {
   119  	sink := log.sink.copyLogger()
   120  	sink.showTime = f
   121  
   122  	return &logger{
   123  		level: log.level,
   124  		sink:  sink,
   125  	}
   126  }
   127  
   128  func (log *logger) Grouped(state bool) {
   129  	if !log.sink.grouppable {
   130  		return
   131  	}
   132  
   133  	if state && log.sink.spinner == nil {
   134  		log.sink.initSpinner()
   135  	} else if !state && log.sink.spinner != nil {
   136  		log.sink.stopSpinner()
   137  	}
   138  
   139  	log.sink.grouped = state
   140  }
   141  
   142  func EnableGroupSession(logger interface{}) func() {
   143  	var l interface{}
   144  
   145  	if lwrap, ok := logger.(interface{ GetSink() logr.LogSink }); ok {
   146  		l = lwrap.GetSink()
   147  	} else {
   148  		l = logger
   149  	}
   150  
   151  	if lgroupable, ok := l.(interface{ Grouped(state bool) }); ok {
   152  		lgroupable.Grouped(true)
   153  		return func() { lgroupable.Grouped(false) }
   154  	}
   155  	return func() {}
   156  }