diff --git a/Gopkg.lock b/Gopkg.lock index 13147e8..4a997db 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -89,14 +89,6 @@ revision = "0ff49de124c6f76f8494e194af75bde0f1a49a29" version = "v1.1.6" -[[projects]] - digest = "1:58999a98719fddbac6303cb17e8d85b945f60b72f48e3a2df6b950b97fa926f1" - name = "github.com/konsorten/go-windows-terminal-sequences" - packages = ["."] - pruneopts = "NUT" - revision = "f55edac94c9bbba5d6182a4be46d86a2c9b5b50e" - version = "v1.0.2" - [[projects]] digest = "1:2f42fa12d6911c7b7659738758631bec870b7e9b4c6be5444f963cdcfccc191f" name = "github.com/modern-go/concurrent" @@ -121,14 +113,6 @@ revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4" version = "v0.8.1" -[[projects]] - digest = "1:f4aaa07a6c33f2b354726d0571acbc8ca118837c75709f6353203ae1a3f8eeab" - name = "github.com/sirupsen/logrus" - packages = ["."] - pruneopts = "NUT" - revision = "839c75faf7f98a33d445d181f3018b5c3409a45e" - version = "v1.4.2" - [[projects]] digest = "1:9d8420bbf131d1618bde6530af37c3799340d3762cc47210c1d9532a4c3a2779" name = "github.com/spf13/pflag" @@ -622,7 +606,6 @@ analyzer-version = 1 input-imports = [ "github.com/pkg/errors", - "github.com/sirupsen/logrus", "gopkg.in/yaml.v2", "k8s.io/api/core/v1", "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1", @@ -655,6 +638,7 @@ "k8s.io/code-generator/cmd/defaulter-gen", "k8s.io/code-generator/cmd/informer-gen", "k8s.io/code-generator/cmd/lister-gen", + "k8s.io/klog", ] solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index d7d3aa4..72b5835 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -8,10 +8,6 @@ required = [ "k8s.io/code-generator/cmd/defaulter-gen", ] -[[constraint]] - name = "github.com/sirupsen/logrus" - version = "1.0.4" - [[constraint]] name = "github.com/pkg/errors" version = "v0.8.0" diff --git a/bin/frameworkbarrier/start.sh b/bin/frameworkbarrier/start.sh index 3b9d1da..f25e96f 100755 --- a/bin/frameworkbarrier/start.sh +++ b/bin/frameworkbarrier/start.sh @@ -30,7 +30,7 @@ BASH_DIR=$(cd $(dirname ${BASH_SOURCE}) && pwd) cd ${BASH_DIR} -./frameworkbarrier +./frameworkbarrier "$@" MNT_DIR=/mnt/frameworkbarrier diff --git a/bin/frameworkcontroller/start.sh b/bin/frameworkcontroller/start.sh index 21c577e..cf88610 100755 --- a/bin/frameworkcontroller/start.sh +++ b/bin/frameworkcontroller/start.sh @@ -30,4 +30,4 @@ BASH_DIR=$(cd $(dirname ${BASH_SOURCE}) && pwd) cd ${BASH_DIR} -./frameworkcontroller +./frameworkcontroller "$@" diff --git a/cmd/frameworkcontroller/main.go b/cmd/frameworkcontroller/main.go index 6e82ff1..b93bc0f 100644 --- a/cmd/frameworkcontroller/main.go +++ b/cmd/frameworkcontroller/main.go @@ -25,9 +25,6 @@ package main import ( "github.com/microsoft/frameworkcontroller/pkg/common" "github.com/microsoft/frameworkcontroller/pkg/controller" - "os" - "os/signal" - "syscall" ) func init() { @@ -35,13 +32,5 @@ func init() { } func main() { - stopCh := make(chan struct{}) - defer close(stopCh) - - go controller.NewFrameworkController().Run(stopCh) - - sigTerm := make(chan os.Signal, 1) - signal.Notify(sigTerm, syscall.SIGTERM) - signal.Notify(sigTerm, syscall.SIGINT) - <-sigTerm + controller.NewFrameworkController().Run(common.NewStopChannel()) } diff --git a/doc/user-manual.md b/doc/user-manual.md index dcd3b0b..8dd4f1f 100644 --- a/doc/user-manual.md +++ b/doc/user-manual.md @@ -84,7 +84,7 @@ All running containers of the Framework will be stopped while the object of the | Code | Body | Description | |:---- |:---- |:---- | | OK(200) | [Framework](../pkg/apis/frameworkcontroller/v1/types.go) | Return current Framework. | -| NotFound(200) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | +| NotFound(404) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | #### DELETE Framework **Request** @@ -119,7 +119,7 @@ Notes: |:---- |:---- |:---- | | OK(200) | [Framework](../pkg/apis/frameworkcontroller/v1/types.go) | The specified Framework is deleting.
Return current Framework. | | OK(200) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is deleted. | -| NotFound(200) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | +| NotFound(404) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | #### GET Framework **Request** @@ -135,7 +135,7 @@ Get the specified Framework. | Code | Body | Description | |:---- |:---- |:---- | | OK(200) | [Framework](../pkg/apis/frameworkcontroller/v1/types.go) | Return current Framework. | -| NotFound(200) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | +| NotFound(404) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | #### LIST Frameworks **Request** @@ -171,7 +171,7 @@ Watch the change events of the specified Framework. | Code | Body | Description | |:---- |:---- |:---- | | OK(200) | [WatchEvent](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#watchevent-v1-meta) | Streaming the change events of the specified Framework. | -| NotFound(200) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | +| NotFound(404) | [Status](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#status-v1-meta) | The specified Framework is not found. | #### WATCH_LIST Frameworks **Request** diff --git a/pkg/apis/frameworkcontroller/v1/funcs.go b/pkg/apis/frameworkcontroller/v1/funcs.go index f47e9a4..8f2621a 100644 --- a/pkg/apis/frameworkcontroller/v1/funcs.go +++ b/pkg/apis/frameworkcontroller/v1/funcs.go @@ -25,10 +25,10 @@ package v1 import ( "fmt" "github.com/microsoft/frameworkcontroller/pkg/common" - log "github.com/sirupsen/logrus" core "k8s.io/api/core/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + "k8s.io/klog" "strconv" "strings" ) @@ -577,7 +577,7 @@ func (f *Framework) TransitionFrameworkState(dstState FrameworkState) { f.Status.State = dstState f.Status.TransitionTime = meta.Now() - log.Infof( + klog.Infof( "[%v]: Transitioned Framework from [%v] to [%v]", f.Key(), srcState, dstState) } @@ -594,7 +594,7 @@ func (f *Framework) TransitionTaskState( taskStatus.State = dstState taskStatus.TransitionTime = meta.Now() - log.Infof( + klog.Infof( "[%v][%v][%v]: Transitioned Task from [%v] to [%v]", f.Key(), taskRoleName, taskIndex, srcState, dstState) } diff --git a/pkg/barrier/barrier.go b/pkg/barrier/barrier.go index a14d173..438696e 100644 --- a/pkg/barrier/barrier.go +++ b/pkg/barrier/barrier.go @@ -27,8 +27,7 @@ import ( ci "github.com/microsoft/frameworkcontroller/pkg/apis/frameworkcontroller/v1" frameworkClient "github.com/microsoft/frameworkcontroller/pkg/client/clientset/versioned" "github.com/microsoft/frameworkcontroller/pkg/common" - "github.com/microsoft/frameworkcontroller/pkg/util" - log "github.com/sirupsen/logrus" + "github.com/microsoft/frameworkcontroller/pkg/internal" "io/ioutil" apiErrors "k8s.io/apimachinery/pkg/api/errors" meta "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -36,6 +35,7 @@ import ( kubeClient "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" + "k8s.io/klog" "os" "strconv" "strings" @@ -134,7 +134,7 @@ func newConfig() *Config { } else { i, err := strconv.ParseInt(barrierCheckIntervalSecStr, 10, 64) if err != nil { - log.Errorf( + klog.Errorf( "Failed to parse ${%v}: %v", EnvNameBarrierCheckIntervalSec, err) exit(ci.CompletionCodeContainerPermanentFailed) @@ -148,7 +148,7 @@ func newConfig() *Config { } else { i, err := strconv.ParseInt(barrierCheckTimeoutSecStr, 10, 64) if err != nil { - log.Errorf( + klog.Errorf( "Failed to parse ${%v}: %v", EnvNameBarrierCheckTimeoutSec, err) exit(ci.CompletionCodeContainerPermanentFailed) @@ -159,19 +159,19 @@ func newConfig() *Config { // Validation errPrefix := "Validation Failed: " if c.FrameworkName == "" { - log.Errorf(errPrefix+ + klog.Errorf(errPrefix+ "${%v} should not be empty", ci.EnvNameFrameworkName) exit(ci.CompletionCodeContainerPermanentFailed) } if c.BarrierCheckIntervalSec < 5 { - log.Errorf(errPrefix+ + klog.Errorf(errPrefix+ "${%v} %v should not be less than 5", EnvNameBarrierCheckIntervalSec, c.BarrierCheckIntervalSec) exit(ci.CompletionCodeContainerPermanentFailed) } if c.BarrierCheckTimeoutSec < 60 || c.BarrierCheckTimeoutSec > 20*60 { - log.Errorf(errPrefix+ + klog.Errorf(errPrefix+ "${%v} %v should not be less than 60 or greater than 20 * 60", EnvNameBarrierCheckTimeoutSec, c.BarrierCheckTimeoutSec) exit(ci.CompletionCodeContainerPermanentFailed) @@ -195,7 +195,7 @@ func buildKubeConfig(bConfig *Config) *rest.Config { kConfig, err := clientcmd.BuildConfigFromFlags( bConfig.KubeApiServerAddress, bConfig.KubeConfigFilePath) if err != nil { - log.Errorf("Failed to build KubeConfig, please ensure "+ + klog.Errorf("Failed to build KubeConfig, please ensure "+ "${KUBE_APISERVER_ADDRESS} or ${KUBECONFIG} or ${HOME}/.kube/config or "+ "${KUBERNETES_SERVICE_HOST}:${KUBERNETES_SERVICE_PORT} is valid: "+ "Error: %v", err) @@ -208,12 +208,12 @@ func buildKubeConfig(bConfig *Config) *rest.Config { // Methods /////////////////////////////////////////////////////////////////////////////////////// func NewFrameworkBarrier() *FrameworkBarrier { - log.Infof("Initializing %v", ComponentName) + klog.Infof("Initializing %v", ComponentName) bConfig := newConfig() - common.LogLines("With Config: \n%v", common.ToYaml(bConfig)) + klog.Infof("With Config: \n%v", common.ToYaml(bConfig)) kConfig := buildKubeConfig(bConfig) - kClient, fClient := util.CreateClients(kConfig) + kClient, fClient := internal.CreateClients(kConfig) return &FrameworkBarrier{ kConfig: kConfig, @@ -224,7 +224,7 @@ func NewFrameworkBarrier() *FrameworkBarrier { } func (b *FrameworkBarrier) Run() { - log.Infof("Running %v", ComponentName) + klog.Infof("Running %v", ComponentName) var f *ci.Framework var err error @@ -242,7 +242,7 @@ func (b *FrameworkBarrier) Run() { isPassed = isBarrierPassed(f) return isPassed, nil } else { - log.Warnf("Failed to get Framework object from ApiServer: %v", err) + klog.Warningf("Failed to get Framework object from ApiServer: %v", err) if apiErrors.IsNotFound(err) { // Permanent Error: Early Stop isPermanentErr = true @@ -256,18 +256,18 @@ func (b *FrameworkBarrier) Run() { }) if isPassed { - log.Infof("BarrierPassed: " + + klog.Infof("BarrierPassed: " + "All Tasks are ready with not nil PodIP.") dumpFramework(f) generateInjector(f) exit(ci.CompletionCodeSucceeded) } else { if err == nil { - log.Errorf("BarrierNotPassed: " + + klog.Errorf("BarrierNotPassed: " + "Timeout to wait all Tasks are ready with not nil PodIP.") exit(ci.CompletionCodeContainerTransientConflictFailed) } else { - log.Errorf("Failed to get Framework object from ApiServer: %v", err) + klog.Errorf("Failed to get Framework object from ApiServer: %v", err) if isPermanentErr { exit(ci.CompletionCodeContainerPermanentFailed) } else { @@ -296,12 +296,12 @@ func isBarrierPassed(f *ci.Framework) bool { // Wait until readyTaskCount is consistent with totalTaskCount. if readyTaskCount == totalTaskCount { - log.Infof("BarrierPassed: "+ + klog.Infof("BarrierPassed: "+ "%v/%v Tasks are ready with not nil PodIP.", readyTaskCount, totalTaskCount) return true } else { - log.Warnf("BarrierNotPassed: "+ + klog.Warningf("BarrierNotPassed: "+ "%v/%v Tasks are ready with not nil PodIP.", readyTaskCount, totalTaskCount) return false @@ -316,13 +316,13 @@ func isTaskReady(taskStatus *ci.TaskStatus) bool { func dumpFramework(f *ci.Framework) { err := ioutil.WriteFile(FrameworkObjectFilePath, []byte(common.ToJson(f)), 0644) if err != nil { - log.Errorf( + klog.Errorf( "Failed to dump the Framework object to local file: %v, %v", FrameworkObjectFilePath, err) exit(ci.CompletionCode(1)) } - log.Infof( + klog.Infof( "Succeeded to dump the Framework object to local file: %v", FrameworkObjectFilePath) } @@ -393,13 +393,13 @@ func generateInjector(f *ci.Framework) { err := ioutil.WriteFile(InjectorFilePath, []byte(injector.String()), 0755) if err != nil { - log.Errorf( + klog.Errorf( "Failed to generate the injector script to local file: %v, %v", InjectorFilePath, err) exit(ci.CompletionCode(1)) } - log.Infof( + klog.Infof( "Succeeded to generate the injector script to local file: %v", InjectorFilePath) } @@ -407,18 +407,18 @@ func generateInjector(f *ci.Framework) { func exit(cc ci.CompletionCode) { logPfx := fmt.Sprintf("ExitCode: %v: Exit with ", cc) if cc == ci.CompletionCodeSucceeded { - log.Infof(logPfx + "success.") + klog.Infof(logPfx + "success.") } else if cc == ci.CompletionCodeContainerTransientFailed { - log.Errorf(logPfx + + klog.Errorf(logPfx + "transient failure to tell controller to retry.") } else if cc == ci.CompletionCodeContainerTransientConflictFailed { - log.Errorf(logPfx + + klog.Errorf(logPfx + "transient conflict failure to tell controller to back off retry.") } else if cc == ci.CompletionCodeContainerPermanentFailed { - log.Errorf(logPfx + + klog.Errorf(logPfx + "permanent failure to tell controller not to retry.") } else { - log.Errorf(logPfx + + klog.Errorf(logPfx + "unknown failure to tell controller to retry within maxRetryCount.") } diff --git a/pkg/common/common_type.go b/pkg/common/types.go similarity index 84% rename from pkg/common/common_type.go rename to pkg/common/types.go index 0d6be10..a018b15 100644 --- a/pkg/common/common_type.go +++ b/pkg/common/types.go @@ -23,8 +23,7 @@ package common import ( - log "github.com/sirupsen/logrus" - "io" + "k8s.io/klog" ) type Empty struct{} @@ -69,20 +68,9 @@ func (s ImmutableSet) Contains(item T) bool { return s.set.Contains(item) } -type LogHook struct { - LogLevels []log.Level - LogWriter io.Writer -} +type KlogWriter struct{} -func (lh *LogHook) Levels() []log.Level { - return lh.LogLevels -} - -func (lh *LogHook) Fire(entry *log.Entry) error { - str, err := entry.String() - if err != nil { - return err - } - _, err = lh.LogWriter.Write([]byte(str)) - return err +func (w KlogWriter) Write(data []byte) (n int, err error) { + klog.InfoDepth(1, string(data)) + return len(data), nil } diff --git a/pkg/common/common_util.go b/pkg/common/utils.go similarity index 75% rename from pkg/common/common_util.go rename to pkg/common/utils.go index ad5de25..cbe266a 100644 --- a/pkg/common/common_util.go +++ b/pkg/common/utils.go @@ -26,15 +26,16 @@ import ( "encoding/json" "flag" "fmt" - log "github.com/sirupsen/logrus" "gopkg.in/yaml.v2" "io/ioutil" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/klog" + "log" "math/rand" "os" - "strings" + "os/signal" + "syscall" "time" ) @@ -113,37 +114,52 @@ func InitAll() { } func InitLogger() { - // K8S library logs to stderr + // Defaulting klog.InitFlags(flag.CommandLine) + flag.Set("v", "2") + + // Configure klog from command line + flag.Parse() + + // Only support stderr logging and not support file logging. + // To achieve file logging, user can redirect the stderr to file and rotate the + // file to avoid out of disk. + // This is because currently file logging in klog has some limitations: + // 1. klog will never remove old files even if the log_file_max_size is exceeded. + // So, the total log data size cannot be limited. + // 2. We do not have the chance to flush log to file, if a panic is called in + // an unmanaged goroutine and no one can recover it in the goroutine. + // So, even if the log about the panic itself can be lost. + flag.Set("logtostderr", "true") flag.Set("alsologtostderr", "true") flag.Set("stderrthreshold", "INFO") klog.SetOutput(ioutil.Discard) - // We log to stdout - log.SetFormatter(&log.TextFormatter{ - DisableColors: true, - // Always log with full timestamp, regardless of whether TTY is attached - DisableTimestamp: false, - FullTimestamp: true, - // Align with k8s.io/apimachinery/pkg/apis/meta/v1.Time - TimestampFormat: time.RFC3339, - }) - - log.SetLevel(log.DebugLevel) - log.SetOutput(os.Stdout) -} - -func LogLines(format string, args ...interface{}) { - lines := strings.Split(fmt.Sprintf(format, args...), "\n") - for _, line := range lines { - log.Infof(line) - } + // Redirect the default golang log to klog + log.SetOutput(KlogWriter{}) + log.SetFlags(0) } func InitRandSeed() { rand.Seed(time.Now().UTC().UnixNano()) } +func NewStopChannel() <-chan struct{} { + stopCh := make(chan struct{}) + + // Stop on shutdown signal: + // Must be a buffered channel, otherwise the shutdown signal may be lost. + shutdownCh := make(chan os.Signal, 1) + signal.Notify(shutdownCh, syscall.SIGINT, syscall.SIGTERM) + go func() { + s := <-shutdownCh + klog.Warningf("Received shutdown signal: %v", s) + close(stopCh) + }() + + return stopCh +} + // Rand in range [min, max] func RandInt64(min int64, max int64) int64 { return min + rand.Int63n(max-min+1) diff --git a/pkg/controller/controller.go b/pkg/controller/controller.go index 985bd68..e276119 100644 --- a/pkg/controller/controller.go +++ b/pkg/controller/controller.go @@ -29,9 +29,8 @@ import ( frameworkInformer "github.com/microsoft/frameworkcontroller/pkg/client/informers/externalversions" frameworkLister "github.com/microsoft/frameworkcontroller/pkg/client/listers/frameworkcontroller/v1" "github.com/microsoft/frameworkcontroller/pkg/common" - "github.com/microsoft/frameworkcontroller/pkg/util" + "github.com/microsoft/frameworkcontroller/pkg/internal" errorWrap "github.com/pkg/errors" - log "github.com/sirupsen/logrus" core "k8s.io/api/core/v1" apiErrors "k8s.io/apimachinery/pkg/api/errors" meta "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -46,6 +45,7 @@ import ( "k8s.io/client-go/tools/cache" "k8s.io/client-go/util/retry" "k8s.io/client-go/util/workqueue" + "k8s.io/klog" "reflect" "strings" "sync" @@ -198,13 +198,13 @@ type ExpectedFrameworkStatusInfo struct { } func NewFrameworkController() *FrameworkController { - log.Infof("Initializing " + ci.ComponentName) + klog.Infof("Initializing " + ci.ComponentName) cConfig := ci.NewConfig() - common.LogLines("With Config: \n%v", common.ToYaml(cConfig)) + klog.Infof("With Config: \n%v", common.ToYaml(cConfig)) kConfig := ci.BuildKubeConfig(cConfig) - kClient, fClient := util.CreateClients(kConfig) + kClient, fClient := internal.CreateClients(kConfig) // Informer resync will periodically replay the event of all objects stored in its cache. // However, by design, Informer and Controller should not miss any event. @@ -289,25 +289,25 @@ func NewFrameworkController() *FrameworkController { // obj could be *ci.Framework or cache.DeletedFinalStateUnknown. func (c *FrameworkController) enqueueFrameworkObj(obj interface{}, msg string) { - key, err := util.GetKey(obj) + key, err := internal.GetKey(obj) if err != nil { - log.Errorf("Failed to get key for obj %#v, skip to enqueue: %v", obj, err) + klog.Errorf("Failed to get key for obj %#v, skip to enqueue: %v", obj, err) return } - _, _, err = util.SplitKey(key) + _, _, err = internal.SplitKey(key) if err != nil { - log.Errorf("Got invalid key %v for obj %#v, skip to enqueue: %v", key, obj, err) + klog.Errorf("Got invalid key %v for obj %#v, skip to enqueue: %v", key, obj, err) return } c.fQueue.Add(key) - log.Infof("[%v]: enqueueFrameworkObj: %v", key, msg) + klog.Infof("[%v]: enqueueFrameworkObj: %v", key, msg) } // obj could be *core.ConfigMap or cache.DeletedFinalStateUnknown. func (c *FrameworkController) enqueueFrameworkConfigMapObj(obj interface{}, msg string) { - if cm := util.ToConfigMap(obj); cm != nil { + if cm := internal.ToConfigMap(obj); cm != nil { if f := c.getConfigMapOwner(cm); f != nil { c.enqueueFrameworkObj(f, msg+": "+cm.Name) } @@ -316,7 +316,7 @@ func (c *FrameworkController) enqueueFrameworkConfigMapObj(obj interface{}, msg // obj could be *core.Pod or cache.DeletedFinalStateUnknown. func (c *FrameworkController) enqueueFrameworkPodObj(obj interface{}, msg string) { - if pod := util.ToPod(obj); pod != nil { + if pod := internal.ToPod(obj); pod != nil { if cm := c.getPodOwner(pod); cm != nil { c.enqueueFrameworkConfigMapObj(cm, msg+": "+pod.Name) } @@ -336,7 +336,7 @@ func (c *FrameworkController) getConfigMapOwner(cm *core.ConfigMap) *ci.Framewor f, err := c.fLister.Frameworks(cm.Namespace).Get(cmOwner.Name) if err != nil { if !apiErrors.IsNotFound(err) { - log.Errorf( + klog.Errorf( "[%v]: ConfigMapOwner %#v cannot be got from local cache: %v", cm.Namespace+"/"+cm.Name, *cmOwner, err) } @@ -365,7 +365,7 @@ func (c *FrameworkController) getPodOwner(pod *core.Pod) *core.ConfigMap { cm, err := c.cmLister.ConfigMaps(pod.Namespace).Get(podOwner.Name) if err != nil { if !apiErrors.IsNotFound(err) { - log.Errorf( + klog.Errorf( "[%v]: PodOwner %#v cannot be got from local cache: %v", pod.Namespace+"/"+pod.Name, *podOwner, err) } @@ -383,11 +383,11 @@ func (c *FrameworkController) getPodOwner(pod *core.Pod) *core.ConfigMap { func (c *FrameworkController) Run(stopCh <-chan struct{}) { defer c.fQueue.ShutDown() - defer log.Errorf("Stopping " + ci.ComponentName) + defer klog.Errorf("Stopping " + ci.ComponentName) defer runtime.HandleCrash() - log.Infof("Recovering " + ci.ComponentName) - util.PutCRD( + klog.Infof("Recovering " + ci.ComponentName) + internal.PutCRD( c.kConfig, ci.BuildFrameworkCRD(), c.cConfig.CRDEstablishedCheckIntervalSec, @@ -404,7 +404,7 @@ func (c *FrameworkController) Run(stopCh <-chan struct{}) { panic(fmt.Errorf("Failed to WaitForCacheSync")) } - log.Infof("Running %v with %v workers", + klog.Infof("Running %v with %v workers", ci.ComponentName, *c.cConfig.WorkerNumber) for i := int32(0); i < *c.cConfig.WorkerNumber; i++ { @@ -417,8 +417,8 @@ func (c *FrameworkController) Run(stopCh <-chan struct{}) { } func (c *FrameworkController) worker(id int32) { - defer log.Errorf("Stopping worker-%v", id) - log.Infof("Running worker-%v", id) + defer klog.Errorf("Stopping worker-%v", id) + klog.Infof("Running worker-%v", id) for c.processNextWorkItem(id) { } @@ -430,7 +430,7 @@ func (c *FrameworkController) processNextWorkItem(id int32) bool { if quit { return false } - log.Infof("[%v]: Assigned to worker-%v", key, id) + klog.Infof("[%v]: Assigned to worker-%v", key, id) // Remove the item from the current processing items to unblock getting the // same item again. @@ -457,19 +457,19 @@ func (c *FrameworkController) processNextWorkItem(id int32) bool { func (c *FrameworkController) syncFramework(key string) (returnedErr error) { startTime := time.Now() logPfx := fmt.Sprintf("[%v]: syncFramework: ", key) - log.Infof(logPfx + "Started") + klog.Infof(logPfx + "Started") defer func() { if returnedErr != nil { // returnedErr is already prefixed with logPfx - log.Warnf(returnedErr.Error()) - log.Warnf(logPfx + + klog.Warningf(returnedErr.Error()) + klog.Warningf(logPfx + "Failed to due to Platform Transient Error. " + "Will enqueue it again after rate limited delay") } - log.Infof(logPfx+"Completed: Duration %v", time.Since(startTime)) + klog.Infof(logPfx+"Completed: Duration %v", time.Since(startTime)) }() - namespace, name, err := util.SplitKey(key) + namespace, name, err := internal.SplitKey(key) if err != nil { // Unreachable panic(fmt.Errorf(logPfx+ @@ -482,7 +482,7 @@ func (c *FrameworkController) syncFramework(key string) (returnedErr error) { if apiErrors.IsNotFound(err) { // GarbageCollectionController will handle the dependent object // deletion according to the ownerReferences. - log.Infof(logPfx+ + klog.Infof(logPfx+ "Skipped: Framework cannot be found in local cache: %v", err) c.deleteExpectedFrameworkStatusInfo(key) return nil @@ -494,7 +494,7 @@ func (c *FrameworkController) syncFramework(key string) (returnedErr error) { if localF.DeletionTimestamp != nil { // Skip syncFramework to avoid fighting with GarbageCollectionController, // because GarbageCollectionController may be deleting the dependent object. - log.Infof(logPfx+ + klog.Infof(logPfx+ "Skipped: Framework is deleting: Will be deleted at %v", localF.DeletionTimestamp) return nil @@ -549,7 +549,7 @@ func (c *FrameworkController) syncFramework(key string) (returnedErr error) { c.updateExpectedFrameworkStatusInfo(f.Key(), f.Status, updateErr == nil) } else { - log.Infof(logPfx + + klog.Infof(logPfx + "Skip to update the expected and remote Framework.Status since " + "they are unchanged") } @@ -564,8 +564,8 @@ func (c *FrameworkController) syncFramework(key string) (returnedErr error) { // Frameworks will be enqueued to sync. func (c *FrameworkController) recoverFrameworkWorkItems(f *ci.Framework) { logPfx := fmt.Sprintf("[%v]: recoverFrameworkWorkItems: ", f.Key()) - log.Infof(logPfx + "Started") - defer func() { log.Infof(logPfx + "Completed") }() + klog.Infof(logPfx + "Started") + defer func() { klog.Infof(logPfx + "Completed") }() if f.Status == nil { return @@ -603,7 +603,7 @@ func (c *FrameworkController) enqueueFrameworkAttemptCreationTimeoutCheck( } c.fQueue.AddAfter(f.Key(), leftDuration) - log.Infof("[%v]: enqueueFrameworkAttemptCreationTimeoutCheck after %v", + klog.Infof("[%v]: enqueueFrameworkAttemptCreationTimeoutCheck after %v", f.Key(), leftDuration) return true } @@ -624,7 +624,7 @@ func (c *FrameworkController) enqueueTaskAttemptCreationTimeoutCheck( } c.fQueue.AddAfter(f.Key(), leftDuration) - log.Infof("[%v][%v][%v]: enqueueTaskAttemptCreationTimeoutCheck after %v", + klog.Infof("[%v][%v][%v]: enqueueTaskAttemptCreationTimeoutCheck after %v", f.Key(), taskRoleName, taskIndex, leftDuration) return true } @@ -643,7 +643,7 @@ func (c *FrameworkController) enqueueFrameworkRetryDelayTimeoutCheck( } c.fQueue.AddAfter(f.Key(), leftDuration) - log.Infof("[%v]: enqueueFrameworkRetryDelayTimeoutCheck after %v", + klog.Infof("[%v]: enqueueFrameworkRetryDelayTimeoutCheck after %v", f.Key(), leftDuration) return true } @@ -664,20 +664,20 @@ func (c *FrameworkController) enqueueTaskRetryDelayTimeoutCheck( } c.fQueue.AddAfter(f.Key(), leftDuration) - log.Infof("[%v][%v][%v]: enqueueTaskRetryDelayTimeoutCheck after %v", + klog.Infof("[%v][%v][%v]: enqueueTaskRetryDelayTimeoutCheck after %v", f.Key(), taskRoleName, taskIndex, leftDuration) return true } func (c *FrameworkController) enqueueFramework(f *ci.Framework, msg string) { c.fQueue.Add(f.Key()) - log.Infof("[%v]: enqueueFramework: %v", f.Key(), msg) + klog.Infof("[%v]: enqueueFramework: %v", f.Key(), msg) } func (c *FrameworkController) syncFrameworkStatus(f *ci.Framework) error { logPfx := fmt.Sprintf("[%v]: syncFrameworkStatus: ", f.Key()) - log.Infof(logPfx + "Started") - defer func() { log.Infof(logPfx + "Completed") }() + klog.Infof(logPfx + "Started") + defer func() { klog.Infof(logPfx + "Completed") }() if f.Status == nil { f.Status = f.NewFrameworkStatus() @@ -690,11 +690,11 @@ func (c *FrameworkController) syncFrameworkStatus(f *ci.Framework) error { func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { logPfx := fmt.Sprintf("[%v]: syncFrameworkState: ", f.Key()) - log.Infof(logPfx + "Started") - defer func() { log.Infof(logPfx + "Completed") }() + klog.Infof(logPfx + "Started") + defer func() { klog.Infof(logPfx + "Completed") }() if f.Status.State == ci.FrameworkCompleted { - log.Infof(logPfx + "Skipped: Framework is already completed") + klog.Infof(logPfx + "Skipped: Framework is already completed") return nil } @@ -716,10 +716,10 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { if f.Spec.ExecutionType == ci.ExecutionStop { diag = fmt.Sprintf("User has requested to stop the Framework") code = ci.CompletionCodeStopFrameworkRequested - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) } else { if c.enqueueFrameworkAttemptCreationTimeoutCheck(f, true) { - log.Infof(logPfx + + klog.Infof(logPfx + "Waiting ConfigMap to appear in the local cache or timeout") return nil } @@ -729,7 +729,7 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { "so consider it was deleted and force delete it", common.SecToDuration(c.cConfig.ObjectLocalCacheCreationTimeoutSec)) code = ci.CompletionCodeConfigMapCreationTimeout - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) } // Ensure cm is deleted in remote to avoid managed cm leak after @@ -746,7 +746,7 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { if f.Status.State != ci.FrameworkAttemptCreationPending { if f.Status.AttemptStatus.CompletionStatus == nil { diag := fmt.Sprintf("ConfigMap was deleted by others") - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) c.completeFrameworkAttempt(f, true, ci.CompletionCodeConfigMapExternalDeleted.NewCompletionStatus(diag)) } else { @@ -773,7 +773,7 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { if f.Status.State == ci.FrameworkAttemptDeletionRequested { // The deletion requested object will never appear again with the same UID, // so always just wait. - log.Infof(logPfx + + klog.Infof(logPfx + "Waiting ConfigMap to disappearing or disappear in the local cache") } else { // At this point, f.Status.State must be in: @@ -787,13 +787,13 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { } else { if f.Status.AttemptStatus.CompletionStatus == nil { diag := fmt.Sprintf("ConfigMap is being deleted by others") - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) f.Status.AttemptStatus.CompletionStatus = ci.CompletionCodeConfigMapExternalDeleted.NewCompletionStatus(diag) } f.TransitionFrameworkState(ci.FrameworkAttemptDeleting) - log.Infof(logPfx + "Waiting ConfigMap to be deleted") + klog.Infof(logPfx + "Waiting ConfigMap to be deleted") } } } @@ -814,14 +814,14 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { // RetryFramework is not yet scheduled, so need to be decided. if retryDecision.ShouldRetry { // scheduleToRetryFramework - log.Infof(logPfx+ + klog.Infof(logPfx+ "Will retry Framework with new FrameworkAttempt: RetryDecision: %v", retryDecision) f.Status.RetryPolicyStatus.RetryDelaySec = &retryDecision.DelaySec } else { // completeFramework - log.Infof(logPfx+ + klog.Infof(logPfx+ "Will complete Framework: RetryDecision: %v", retryDecision) @@ -835,18 +835,18 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { // RetryFramework is already scheduled, so just need to check whether it // should be executed now. if f.Spec.ExecutionType == ci.ExecutionStop { - log.Infof(logPfx + + klog.Infof(logPfx + "User has requested to stop the Framework, " + "so immediately retry without delay") } else { if c.enqueueFrameworkRetryDelayTimeoutCheck(f, true) { - log.Infof(logPfx + "Waiting Framework to retry after delay") + klog.Infof(logPfx + "Waiting Framework to retry after delay") return nil } } // retryFramework - log.Infof(logPfx + "Retry Framework") + klog.Infof(logPfx + "Retry Framework") f.Status.RetryPolicyStatus.TotalRetriedCount++ if retryDecision.IsAccountable { f.Status.RetryPolicyStatus.AccountableRetriedCount++ @@ -865,7 +865,7 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { if f.Status.State == ci.FrameworkAttemptCreationPending { if f.Spec.ExecutionType == ci.ExecutionStop { diag := fmt.Sprintf("User has requested to stop the Framework") - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) // Ensure cm is deleted in remote to avoid managed cm leak after // FrameworkAttemptCompleted. @@ -897,7 +897,7 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { // The ground truth cm is the local cached one instead of the remote one, // so need to wait before continue the sync. - log.Infof(logPfx + + klog.Infof(logPfx + "Waiting ConfigMap to appear in the local cache or timeout") return nil } @@ -912,7 +912,7 @@ func (c *FrameworkController) syncFrameworkState(f *ci.Framework) (err error) { if !f.IsCompleting() { if f.Spec.ExecutionType == ci.ExecutionStop { diag := fmt.Sprintf("User has requested to stop the Framework") - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) c.completeFrameworkAttempt(f, false, ci.CompletionCodeStopFrameworkRequested.NewCompletionStatus(diag)) } @@ -1026,7 +1026,7 @@ func (c *FrameworkController) deleteConfigMap( } } - log.Infof( + klog.Infof( "[%v]: Succeeded to delete ConfigMap %v, %v: force: %v", f.Key(), cmName, cmUID, force) return nil @@ -1055,7 +1055,7 @@ func (c *FrameworkController) createConfigMap( return nil, fmt.Errorf(errPfx+"%v", createErr) } else { - log.Infof( + klog.Infof( "[%v]: Succeeded to create ConfigMap %v", f.Key(), cm.Name) return remoteCM, nil @@ -1065,12 +1065,12 @@ func (c *FrameworkController) createConfigMap( func (c *FrameworkController) syncTaskRoleStatuses( f *ci.Framework, cm *core.ConfigMap) (err error) { logPfx := fmt.Sprintf("[%v]: syncTaskRoleStatuses: ", f.Key()) - log.Infof(logPfx + "Started") - defer func() { log.Infof(logPfx + "Completed") }() + klog.Infof(logPfx + "Started") + defer func() { klog.Infof(logPfx + "Completed") }() errs := []error{} for _, taskRoleStatus := range f.TaskRoleStatuses() { - log.Infof("[%v][%v]: syncTaskRoleStatus", f.Key(), taskRoleStatus.Name) + klog.Infof("[%v][%v]: syncTaskRoleStatus", f.Key(), taskRoleStatus.Name) for _, taskStatus := range taskRoleStatus.TaskStatuses { // At this point, f.Status.State must be in: // {FrameworkAttemptPreparing, FrameworkAttemptRunning, @@ -1091,8 +1091,8 @@ func (c *FrameworkController) syncTaskState( taskRoleName string, taskIndex int32) (err error) { logPfx := fmt.Sprintf("[%v][%v][%v]: syncTaskState: ", f.Key(), taskRoleName, taskIndex) - log.Infof(logPfx + "Started") - defer func() { log.Infof(logPfx + "Completed") }() + klog.Infof(logPfx + "Started") + defer func() { klog.Infof(logPfx + "Completed") }() taskRoleSpec := f.TaskRoleSpec(taskRoleName) taskSpec := taskRoleSpec.Task @@ -1106,7 +1106,7 @@ func (c *FrameworkController) syncTaskState( // but the FrameworkAttemptDeletionPending is not persisted, the TaskCompleted // should have already triggered and persisted FrameworkAttemptDeletionPending // in previous sync, so current sync should have already been skipped but not. - log.Infof(logPfx + "Skipped: Task is already completed") + klog.Infof(logPfx + "Skipped: Task is already completed") return nil } @@ -1124,7 +1124,7 @@ func (c *FrameworkController) syncTaskState( // pod is remote creation requested but not found in the local cache. if taskStatus.State == ci.TaskAttemptCreationRequested { if c.enqueueTaskAttemptCreationTimeoutCheck(f, taskRoleName, taskIndex, true) { - log.Infof(logPfx + + klog.Infof(logPfx + "Waiting Pod to appear in the local cache or timeout") return nil } @@ -1133,7 +1133,7 @@ func (c *FrameworkController) syncTaskState( "Pod does not appear in the local cache within timeout %v, "+ "so consider it was deleted and force delete it", common.SecToDuration(c.cConfig.ObjectLocalCacheCreationTimeoutSec)) - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) // Ensure pod is deleted in remote to avoid managed pod leak after // TaskAttemptCompleted. @@ -1150,7 +1150,7 @@ func (c *FrameworkController) syncTaskState( if taskStatus.State != ci.TaskAttemptCreationPending { if taskStatus.AttemptStatus.CompletionStatus == nil { diag := fmt.Sprintf("Pod was deleted by others") - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) c.completeTaskAttempt(f, taskRoleName, taskIndex, true, ci.CompletionCodePodExternalDeleted.NewCompletionStatus(diag)) } else { @@ -1177,7 +1177,7 @@ func (c *FrameworkController) syncTaskState( if taskStatus.State == ci.TaskAttemptDeletionRequested { // The deletion requested object will never appear again with the same UID, // so always just wait. - log.Infof(logPfx + + klog.Infof(logPfx + "Waiting Pod to disappearing or disappear in the local cache") return nil } @@ -1195,7 +1195,7 @@ func (c *FrameworkController) syncTaskState( // it will only be automatically deleted after the kubelet comes back and // kills the Pod. if pod.Status.Phase == core.PodUnknown { - log.Infof(logPfx+ + klog.Infof(logPfx+ "Waiting Pod to be deleted or deleting or transitioned from %v", pod.Status.Phase) return nil @@ -1214,7 +1214,7 @@ func (c *FrameworkController) syncTaskState( return nil } else if pod.Status.Phase == core.PodSucceeded { diag := fmt.Sprintf("Pod succeeded") - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) c.completeTaskAttempt(f, taskRoleName, taskIndex, false, ci.CompletionCodeSucceeded.NewCompletionStatus(diag)) return nil @@ -1248,14 +1248,14 @@ func (c *FrameworkController) syncTaskState( diag := fmt.Sprintf( "Pod failed without any non-zero container exit code, maybe " + "stopped by the system") - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) c.completeTaskAttempt(f, taskRoleName, taskIndex, false, ci.CompletionCodePodFailedWithoutFailedContainer.NewCompletionStatus(diag)) } else { diag := fmt.Sprintf( "Pod failed with non-zero container exit code: %v", strings.Join(allContainerDiags, ", ")) - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) if strings.Contains(diag, string(ci.ReasonOOMKilled)) { c.completeTaskAttempt(f, taskRoleName, taskIndex, false, ci.CompletionCodeContainerOOMKilled.NewCompletionStatus(diag)) @@ -1272,13 +1272,13 @@ func (c *FrameworkController) syncTaskState( } else { if taskStatus.AttemptStatus.CompletionStatus == nil { diag := fmt.Sprintf("Pod is being deleted by others") - log.Warnf(logPfx + diag) + klog.Warningf(logPfx + diag) taskStatus.AttemptStatus.CompletionStatus = ci.CompletionCodePodExternalDeleted.NewCompletionStatus(diag) } f.TransitionTaskState(taskRoleName, taskIndex, ci.TaskAttemptDeleting) - log.Infof(logPfx + "Waiting Pod to be deleted") + klog.Infof(logPfx + "Waiting Pod to be deleted") return nil } } @@ -1297,14 +1297,14 @@ func (c *FrameworkController) syncTaskState( // RetryTask is not yet scheduled, so need to be decided. if retryDecision.ShouldRetry { // scheduleToRetryTask - log.Infof(logPfx+ + klog.Infof(logPfx+ "Will retry Task with new TaskAttempt: RetryDecision: %v", retryDecision) taskStatus.RetryPolicyStatus.RetryDelaySec = &retryDecision.DelaySec } else { // completeTask - log.Infof(logPfx+ + klog.Infof(logPfx+ "Will complete Task: RetryDecision: %v", retryDecision) @@ -1317,12 +1317,12 @@ func (c *FrameworkController) syncTaskState( // RetryTask is already scheduled, so just need to check whether it // should be executed now. if c.enqueueTaskRetryDelayTimeoutCheck(f, taskRoleName, taskIndex, true) { - log.Infof(logPfx + "Waiting Task to retry after delay") + klog.Infof(logPfx + "Waiting Task to retry after delay") return nil } // retryTask - log.Infof(logPfx + "Retry Task") + klog.Infof(logPfx + "Retry Task") taskStatus.RetryPolicyStatus.TotalRetriedCount++ if retryDecision.IsAccountable { taskStatus.RetryPolicyStatus.AccountableRetriedCount++ @@ -1338,7 +1338,7 @@ func (c *FrameworkController) syncTaskState( if taskStatus.State == ci.TaskAttemptCreationPending { if f.IsCompleting() { - log.Infof(logPfx + "Skip to createTaskAttempt: " + + klog.Infof(logPfx + "Skip to createTaskAttempt: " + "FrameworkAttempt is completing") return nil } @@ -1353,7 +1353,7 @@ func (c *FrameworkController) syncTaskState( "Pod Spec is invalid in TaskRole [%v]: "+ "Triggered by Task [%v][%v]: Diagnostics: %v", taskRoleName, taskRoleName, taskIndex, apiErr) - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) // Ensure pod is deleted in remote to avoid managed pod leak after // TaskAttemptCompleted. @@ -1382,7 +1382,7 @@ func (c *FrameworkController) syncTaskState( // The ground truth pod is the local cached one instead of the remote one, // so need to wait before continue the sync. - log.Infof(logPfx + + klog.Infof(logPfx + "Waiting Pod to appear in the local cache or timeout") return nil } @@ -1391,7 +1391,7 @@ func (c *FrameworkController) syncTaskState( if taskStatus.State == ci.TaskCompleted { if f.IsCompleting() { - log.Infof(logPfx + "Skip to attemptToCompleteFrameworkAttempt: " + + klog.Infof(logPfx + "Skip to attemptToCompleteFrameworkAttempt: " + "FrameworkAttempt is completing") return nil } @@ -1409,7 +1409,7 @@ func (c *FrameworkController) syncTaskState( "Triggered by Task [%v][%v]: Diagnostics: %v", failedTaskCount, minFailedTaskCount, taskRoleName, taskRoleName, taskIndex, taskStatus.AttemptStatus.CompletionStatus.Diagnostics) - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) c.completeFrameworkAttempt(f, false, taskStatus.AttemptStatus.CompletionStatus.Code.NewCompletionStatus(diag)) return nil @@ -1424,7 +1424,7 @@ func (c *FrameworkController) syncTaskState( "Triggered by Task [%v][%v]: Diagnostics: %v", succeededTaskCount, minSucceededTaskCount, taskRoleName, taskRoleName, taskIndex, taskStatus.AttemptStatus.CompletionStatus.Diagnostics) - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) c.completeFrameworkAttempt(f, false, ci.CompletionCodeSucceeded.NewCompletionStatus(diag)) return nil @@ -1441,7 +1441,7 @@ func (c *FrameworkController) syncTaskState( "Triggered by Task [%v][%v]: Diagnostics: %v", totalTaskCount, failedTaskCount, taskRoleName, taskIndex, taskStatus.AttemptStatus.CompletionStatus.Diagnostics) - log.Infof(logPfx + diag) + klog.Infof(logPfx + diag) c.completeFrameworkAttempt(f, false, ci.CompletionCodeSucceeded.NewCompletionStatus(diag)) return nil @@ -1545,7 +1545,7 @@ func (c *FrameworkController) deletePod( } } - log.Infof( + klog.Infof( "[%v][%v][%v]: Succeeded to delete Pod %v, %v: force: %v", f.Key(), taskRoleName, taskIndex, podName, podUID, force) return nil @@ -1575,7 +1575,7 @@ func (c *FrameworkController) createPod( return nil, errorWrap.Wrapf(createErr, errPfx) } else { - log.Infof( + klog.Infof( "[%v][%v][%v]: Succeeded to create Pod %v", f.Key(), taskRoleName, taskIndex, pod.Name) return remotePod, nil @@ -1600,18 +1600,18 @@ func (c *FrameworkController) completeTaskAttempt( f.TransitionTaskState(taskRoleName, taskIndex, ci.TaskAttemptCompleted) if taskStatus.TaskAttemptInstanceUID() == nil { - log.Infof(logPfx+ + klog.Infof(logPfx+ "TaskAttempt %v is completed with CompletionStatus: %v", taskStatus.TaskAttemptID(), taskStatus.AttemptStatus.CompletionStatus) } else { - log.Infof(logPfx+ + klog.Infof(logPfx+ "TaskAttemptInstance %v is completed with CompletionStatus: %v", *taskStatus.TaskAttemptInstanceUID(), taskStatus.AttemptStatus.CompletionStatus) } // To ensure the completed TaskAttempt is persisted before exposed, // we need to wait until next sync to expose it, so manually enqueue a sync. - log.Infof(logPfx + "Waiting the completed TaskAttempt to be persisted") + klog.Infof(logPfx + "Waiting the completed TaskAttempt to be persisted") c.enqueueFramework(f, "TaskAttemptCompleted") } else { f.TransitionTaskState(taskRoleName, taskIndex, ci.TaskAttemptDeletionPending) @@ -1619,7 +1619,7 @@ func (c *FrameworkController) completeTaskAttempt( // To ensure the CompletionStatus is persisted before deleting the pod, // we need to wait until next sync to delete the pod, so manually enqueue // a sync. - log.Infof(logPfx + "Waiting the CompletionStatus to be persisted") + klog.Infof(logPfx + "Waiting the CompletionStatus to be persisted") c.enqueueFramework(f, "TaskAttemptDeletionPending") } } @@ -1664,18 +1664,18 @@ func (c *FrameworkController) completeFrameworkAttempt( f.TransitionFrameworkState(ci.FrameworkAttemptCompleted) if f.FrameworkAttemptInstanceUID() == nil { - log.Infof(logPfx+ + klog.Infof(logPfx+ "FrameworkAttempt %v is completed with CompletionStatus: %v", f.FrameworkAttemptID(), f.Status.AttemptStatus.CompletionStatus) } else { - log.Infof(logPfx+ + klog.Infof(logPfx+ "FrameworkAttemptInstance %v is completed with CompletionStatus: %v", *f.FrameworkAttemptInstanceUID(), f.Status.AttemptStatus.CompletionStatus) } // To ensure the completed FrameworkAttempt is persisted before exposed, // we need to wait until next sync to expose it, so manually enqueue a sync. - log.Infof(logPfx + "Waiting the completed FrameworkAttempt to be persisted") + klog.Infof(logPfx + "Waiting the completed FrameworkAttempt to be persisted") c.enqueueFramework(f, "FrameworkAttemptCompleted") } else { f.TransitionFrameworkState(ci.FrameworkAttemptDeletionPending) @@ -1683,15 +1683,15 @@ func (c *FrameworkController) completeFrameworkAttempt( // To ensure the CompletionStatus is persisted before deleting the cm, // we need to wait until next sync to delete the cm, so manually enqueue // a sync. - log.Infof(logPfx + "Waiting the CompletionStatus to be persisted") + klog.Infof(logPfx + "Waiting the CompletionStatus to be persisted") c.enqueueFramework(f, "FrameworkAttemptDeletionPending") } } func (c *FrameworkController) updateRemoteFrameworkStatus(f *ci.Framework) error { logPfx := fmt.Sprintf("[%v]: updateRemoteFrameworkStatus: ", f.Key()) - log.Infof(logPfx + "Started") - defer func() { log.Infof(logPfx + "Completed") }() + klog.Infof(logPfx + "Started") + defer func() { klog.Infof(logPfx + "Completed") }() tried := false updateErr := retry.RetryOnConflict(retry.DefaultRetry, func() error { @@ -1745,13 +1745,13 @@ func (c *FrameworkController) getExpectedFrameworkStatusInfo(key string) *Expect } func (c *FrameworkController) deleteExpectedFrameworkStatusInfo(key string) { - log.Infof("[%v]: deleteExpectedFrameworkStatusInfo: ", key) + klog.Infof("[%v]: deleteExpectedFrameworkStatusInfo: ", key) c.fExpectedStatusInfos.Delete(key) } func (c *FrameworkController) updateExpectedFrameworkStatusInfo(key string, status *ci.FrameworkStatus, remoteSynced bool) { - log.Infof("[%v]: updateExpectedFrameworkStatusInfo", key) + klog.Infof("[%v]: updateExpectedFrameworkStatusInfo", key) c.fExpectedStatusInfos.Store(key, &ExpectedFrameworkStatusInfo{ status: status, remoteSynced: remoteSynced, diff --git a/pkg/util/crd_util.go b/pkg/internal/utils.go similarity index 64% rename from pkg/util/crd_util.go rename to pkg/internal/utils.go index c76a421..53277f4 100644 --- a/pkg/util/crd_util.go +++ b/pkg/internal/utils.go @@ -20,21 +20,40 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE -package util +package internal import ( "fmt" + frameworkClient "github.com/microsoft/frameworkcontroller/pkg/client/clientset/versioned" "github.com/microsoft/frameworkcontroller/pkg/common" - log "github.com/sirupsen/logrus" + core "k8s.io/api/core/v1" apiExtensions "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1" apiClient "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset" apiErrors "k8s.io/apimachinery/pkg/api/errors" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/wait" + kubeClient "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" + "k8s.io/client-go/tools/cache" + "k8s.io/klog" "reflect" ) +func CreateClients(kConfig *rest.Config) ( + kubeClient.Interface, frameworkClient.Interface) { + kClient, err := kubeClient.NewForConfig(kConfig) + if err != nil { + panic(fmt.Errorf("Failed to create KubeClient: %v", err)) + } + + fClient, err := frameworkClient.NewForConfig(kConfig) + if err != nil { + panic(fmt.Errorf("Failed to create FrameworkClient: %v", err)) + } + + return kClient, fClient +} + func PutCRD( config *rest.Config, crd *apiExtensions.CustomResourceDefinition, establishedCheckIntervalSec *int64, establishedCheckTimeoutSec *int64) { @@ -44,7 +63,7 @@ func PutCRD( if err != nil { panic(fmt.Errorf("Failed to put CRD: %v", err)) } else { - log.Infof("Succeeded to put CRD") + klog.Infof("Succeeded to put CRD") } } @@ -55,7 +74,7 @@ func DeleteCRD(config *rest.Config, name string) { if err != nil && !apiErrors.IsNotFound(err) { panic(fmt.Errorf("Failed to delete CRD: %v", err)) } else { - log.Infof("Succeeded to delete CRD") + klog.Infof("Succeeded to delete CRD") } } @@ -74,7 +93,7 @@ func putCRDInternal( remoteCRD, err := client.ApiextensionsV1beta1().CustomResourceDefinitions().Get(newCRD.Name, meta.GetOptions{}) if err == nil { - log.Infof("Update CRD %v", newCRD.Name) + klog.Infof("Update CRD %v", newCRD.Name) if !reflect.DeepEqual(remoteCRD.Spec, newCRD.Spec) { updateCRD := remoteCRD updateCRD.Spec = newCRD.Spec @@ -84,7 +103,7 @@ func putCRDInternal( } } } else if apiErrors.IsNotFound(err) { - log.Infof("Create CRD %v", newCRD.Name) + klog.Infof("Create CRD %v", newCRD.Name) remoteCRD, err = client.ApiextensionsV1beta1().CustomResourceDefinitions().Create(newCRD) if err != nil { return err @@ -117,3 +136,61 @@ func isCRDEstablished(crd *apiExtensions.CustomResourceDefinition) bool { } return false } + +func GetKey(obj interface{}) (string, error) { + return cache.DeletionHandlingMetaNamespaceKeyFunc(obj) +} + +func SplitKey(key string) (namespace, name string, err error) { + return cache.SplitMetaNamespaceKey(key) +} + +// obj could be *core.ConfigMap or cache.DeletedFinalStateUnknown. +func ToConfigMap(obj interface{}) *core.ConfigMap { + cm, ok := obj.(*core.ConfigMap) + + if !ok { + deletedFinalStateUnknown, ok := obj.(cache.DeletedFinalStateUnknown) + if !ok { + klog.Errorf( + "Failed to convert obj to ConfigMap or DeletedFinalStateUnknown: %#v", + obj) + return nil + } + + cm, ok = deletedFinalStateUnknown.Obj.(*core.ConfigMap) + if !ok { + klog.Errorf( + "Failed to convert DeletedFinalStateUnknown.Obj to ConfigMap: %#v", + deletedFinalStateUnknown) + return nil + } + } + + return cm +} + +// obj could be *core.Pod or cache.DeletedFinalStateUnknown. +func ToPod(obj interface{}) *core.Pod { + pod, ok := obj.(*core.Pod) + + if !ok { + deletedFinalStateUnknown, ok := obj.(cache.DeletedFinalStateUnknown) + if !ok { + klog.Errorf( + "Failed to convert obj to Pod or DeletedFinalStateUnknown: %#v", + obj) + return nil + } + + pod, ok = deletedFinalStateUnknown.Obj.(*core.Pod) + if !ok { + klog.Errorf( + "Failed to convert DeletedFinalStateUnknown.Obj to Pod: %#v", + deletedFinalStateUnknown) + return nil + } + } + + return pod +} diff --git a/pkg/util/kube_util.go b/pkg/util/kube_util.go deleted file mode 100644 index efa7b5f..0000000 --- a/pkg/util/kube_util.go +++ /dev/null @@ -1,106 +0,0 @@ -// MIT License -// -// Copyright (c) Microsoft Corporation. All rights reserved. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE - -package util - -import ( - "fmt" - frameworkClient "github.com/microsoft/frameworkcontroller/pkg/client/clientset/versioned" - log "github.com/sirupsen/logrus" - core "k8s.io/api/core/v1" - kubeClient "k8s.io/client-go/kubernetes" - "k8s.io/client-go/rest" - "k8s.io/client-go/tools/cache" -) - -func CreateClients(kConfig *rest.Config) ( - kubeClient.Interface, frameworkClient.Interface) { - kClient, err := kubeClient.NewForConfig(kConfig) - if err != nil { - panic(fmt.Errorf("Failed to create KubeClient: %v", err)) - } - - fClient, err := frameworkClient.NewForConfig(kConfig) - if err != nil { - panic(fmt.Errorf("Failed to create FrameworkClient: %v", err)) - } - - return kClient, fClient -} - -func GetKey(obj interface{}) (string, error) { - return cache.DeletionHandlingMetaNamespaceKeyFunc(obj) -} - -func SplitKey(key string) (namespace, name string, err error) { - return cache.SplitMetaNamespaceKey(key) -} - -// obj could be *core.ConfigMap or cache.DeletedFinalStateUnknown. -func ToConfigMap(obj interface{}) *core.ConfigMap { - cm, ok := obj.(*core.ConfigMap) - - if !ok { - deletedFinalStateUnknown, ok := obj.(cache.DeletedFinalStateUnknown) - if !ok { - log.Errorf( - "Failed to convert obj to ConfigMap or DeletedFinalStateUnknown: %#v", - obj) - return nil - } - - cm, ok = deletedFinalStateUnknown.Obj.(*core.ConfigMap) - if !ok { - log.Errorf( - "Failed to convert DeletedFinalStateUnknown.Obj to ConfigMap: %#v", - deletedFinalStateUnknown) - return nil - } - } - - return cm -} - -// obj could be *core.Pod or cache.DeletedFinalStateUnknown. -func ToPod(obj interface{}) *core.Pod { - pod, ok := obj.(*core.Pod) - - if !ok { - deletedFinalStateUnknown, ok := obj.(cache.DeletedFinalStateUnknown) - if !ok { - log.Errorf( - "Failed to convert obj to Pod or DeletedFinalStateUnknown: %#v", - obj) - return nil - } - - pod, ok = deletedFinalStateUnknown.Obj.(*core.Pod) - if !ok { - log.Errorf( - "Failed to convert DeletedFinalStateUnknown.Obj to Pod: %#v", - deletedFinalStateUnknown) - return nil - } - } - - return pod -} diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/LICENSE b/vendor/github.com/konsorten/go-windows-terminal-sequences/LICENSE deleted file mode 100644 index 14127cd..0000000 --- a/vendor/github.com/konsorten/go-windows-terminal-sequences/LICENSE +++ /dev/null @@ -1,9 +0,0 @@ -(The MIT License) - -Copyright (c) 2017 marvin + konsorten GmbH (open-source@konsorten.de) - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences.go b/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences.go deleted file mode 100644 index ef18d8f..0000000 --- a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences.go +++ /dev/null @@ -1,36 +0,0 @@ -// +build windows - -package sequences - -import ( - "syscall" - "unsafe" -) - -var ( - kernel32Dll *syscall.LazyDLL = syscall.NewLazyDLL("Kernel32.dll") - setConsoleMode *syscall.LazyProc = kernel32Dll.NewProc("SetConsoleMode") -) - -func EnableVirtualTerminalProcessing(stream syscall.Handle, enable bool) error { - const ENABLE_VIRTUAL_TERMINAL_PROCESSING uint32 = 0x4 - - var mode uint32 - err := syscall.GetConsoleMode(syscall.Stdout, &mode) - if err != nil { - return err - } - - if enable { - mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING - } else { - mode &^= ENABLE_VIRTUAL_TERMINAL_PROCESSING - } - - ret, _, err := setConsoleMode.Call(uintptr(unsafe.Pointer(stream)), uintptr(mode)) - if ret == 0 { - return err - } - - return nil -} diff --git a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences_dummy.go b/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences_dummy.go deleted file mode 100644 index df61a6f..0000000 --- a/vendor/github.com/konsorten/go-windows-terminal-sequences/sequences_dummy.go +++ /dev/null @@ -1,11 +0,0 @@ -// +build linux darwin - -package sequences - -import ( - "fmt" -) - -func EnableVirtualTerminalProcessing(stream uintptr, enable bool) error { - return fmt.Errorf("windows only package") -} diff --git a/vendor/github.com/sirupsen/logrus/LICENSE b/vendor/github.com/sirupsen/logrus/LICENSE deleted file mode 100644 index f090cb4..0000000 --- a/vendor/github.com/sirupsen/logrus/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2014 Simon Eskildsen - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. diff --git a/vendor/github.com/sirupsen/logrus/alt_exit.go b/vendor/github.com/sirupsen/logrus/alt_exit.go deleted file mode 100644 index 8fd189e..0000000 --- a/vendor/github.com/sirupsen/logrus/alt_exit.go +++ /dev/null @@ -1,76 +0,0 @@ -package logrus - -// The following code was sourced and modified from the -// https://github.com/tebeka/atexit package governed by the following license: -// -// Copyright (c) 2012 Miki Tebeka . -// -// Permission is hereby granted, free of charge, to any person obtaining a copy of -// this software and associated documentation files (the "Software"), to deal in -// the Software without restriction, including without limitation the rights to -// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -// the Software, and to permit persons to whom the Software is furnished to do so, -// subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -import ( - "fmt" - "os" -) - -var handlers = []func(){} - -func runHandler(handler func()) { - defer func() { - if err := recover(); err != nil { - fmt.Fprintln(os.Stderr, "Error: Logrus exit handler error:", err) - } - }() - - handler() -} - -func runHandlers() { - for _, handler := range handlers { - runHandler(handler) - } -} - -// Exit runs all the Logrus atexit handlers and then terminates the program using os.Exit(code) -func Exit(code int) { - runHandlers() - os.Exit(code) -} - -// RegisterExitHandler appends a Logrus Exit handler to the list of handlers, -// call logrus.Exit to invoke all handlers. The handlers will also be invoked when -// any Fatal log entry is made. -// -// This method is useful when a caller wishes to use logrus to log a fatal -// message but also needs to gracefully shutdown. An example usecase could be -// closing database connections, or sending a alert that the application is -// closing. -func RegisterExitHandler(handler func()) { - handlers = append(handlers, handler) -} - -// DeferExitHandler prepends a Logrus Exit handler to the list of handlers, -// call logrus.Exit to invoke all handlers. The handlers will also be invoked when -// any Fatal log entry is made. -// -// This method is useful when a caller wishes to use logrus to log a fatal -// message but also needs to gracefully shutdown. An example usecase could be -// closing database connections, or sending a alert that the application is -// closing. -func DeferExitHandler(handler func()) { - handlers = append([]func(){handler}, handlers...) -} diff --git a/vendor/github.com/sirupsen/logrus/doc.go b/vendor/github.com/sirupsen/logrus/doc.go deleted file mode 100644 index da67aba..0000000 --- a/vendor/github.com/sirupsen/logrus/doc.go +++ /dev/null @@ -1,26 +0,0 @@ -/* -Package logrus is a structured logger for Go, completely API compatible with the standard library logger. - - -The simplest way to use Logrus is simply the package-level exported logger: - - package main - - import ( - log "github.com/sirupsen/logrus" - ) - - func main() { - log.WithFields(log.Fields{ - "animal": "walrus", - "number": 1, - "size": 10, - }).Info("A walrus appears") - } - -Output: - time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10 - -For a full guide visit https://github.com/sirupsen/logrus -*/ -package logrus diff --git a/vendor/github.com/sirupsen/logrus/entry.go b/vendor/github.com/sirupsen/logrus/entry.go deleted file mode 100644 index 63e2558..0000000 --- a/vendor/github.com/sirupsen/logrus/entry.go +++ /dev/null @@ -1,407 +0,0 @@ -package logrus - -import ( - "bytes" - "context" - "fmt" - "os" - "reflect" - "runtime" - "strings" - "sync" - "time" -) - -var ( - bufferPool *sync.Pool - - // qualified package name, cached at first use - logrusPackage string - - // Positions in the call stack when tracing to report the calling method - minimumCallerDepth int - - // Used for caller information initialisation - callerInitOnce sync.Once -) - -const ( - maximumCallerDepth int = 25 - knownLogrusFrames int = 4 -) - -func init() { - bufferPool = &sync.Pool{ - New: func() interface{} { - return new(bytes.Buffer) - }, - } - - // start at the bottom of the stack before the package-name cache is primed - minimumCallerDepth = 1 -} - -// Defines the key when adding errors using WithError. -var ErrorKey = "error" - -// An entry is the final or intermediate Logrus logging entry. It contains all -// the fields passed with WithField{,s}. It's finally logged when Trace, Debug, -// Info, Warn, Error, Fatal or Panic is called on it. These objects can be -// reused and passed around as much as you wish to avoid field duplication. -type Entry struct { - Logger *Logger - - // Contains all the fields set by the user. - Data Fields - - // Time at which the log entry was created - Time time.Time - - // Level the log entry was logged at: Trace, Debug, Info, Warn, Error, Fatal or Panic - // This field will be set on entry firing and the value will be equal to the one in Logger struct field. - Level Level - - // Calling method, with package name - Caller *runtime.Frame - - // Message passed to Trace, Debug, Info, Warn, Error, Fatal or Panic - Message string - - // When formatter is called in entry.log(), a Buffer may be set to entry - Buffer *bytes.Buffer - - // Contains the context set by the user. Useful for hook processing etc. - Context context.Context - - // err may contain a field formatting error - err string -} - -func NewEntry(logger *Logger) *Entry { - return &Entry{ - Logger: logger, - // Default is three fields, plus one optional. Give a little extra room. - Data: make(Fields, 6), - } -} - -// Returns the string representation from the reader and ultimately the -// formatter. -func (entry *Entry) String() (string, error) { - serialized, err := entry.Logger.Formatter.Format(entry) - if err != nil { - return "", err - } - str := string(serialized) - return str, nil -} - -// Add an error as single field (using the key defined in ErrorKey) to the Entry. -func (entry *Entry) WithError(err error) *Entry { - return entry.WithField(ErrorKey, err) -} - -// Add a context to the Entry. -func (entry *Entry) WithContext(ctx context.Context) *Entry { - return &Entry{Logger: entry.Logger, Data: entry.Data, Time: entry.Time, err: entry.err, Context: ctx} -} - -// Add a single field to the Entry. -func (entry *Entry) WithField(key string, value interface{}) *Entry { - return entry.WithFields(Fields{key: value}) -} - -// Add a map of fields to the Entry. -func (entry *Entry) WithFields(fields Fields) *Entry { - data := make(Fields, len(entry.Data)+len(fields)) - for k, v := range entry.Data { - data[k] = v - } - fieldErr := entry.err - for k, v := range fields { - isErrField := false - if t := reflect.TypeOf(v); t != nil { - switch t.Kind() { - case reflect.Func: - isErrField = true - case reflect.Ptr: - isErrField = t.Elem().Kind() == reflect.Func - } - } - if isErrField { - tmp := fmt.Sprintf("can not add field %q", k) - if fieldErr != "" { - fieldErr = entry.err + ", " + tmp - } else { - fieldErr = tmp - } - } else { - data[k] = v - } - } - return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context} -} - -// Overrides the time of the Entry. -func (entry *Entry) WithTime(t time.Time) *Entry { - return &Entry{Logger: entry.Logger, Data: entry.Data, Time: t, err: entry.err, Context: entry.Context} -} - -// getPackageName reduces a fully qualified function name to the package name -// There really ought to be to be a better way... -func getPackageName(f string) string { - for { - lastPeriod := strings.LastIndex(f, ".") - lastSlash := strings.LastIndex(f, "/") - if lastPeriod > lastSlash { - f = f[:lastPeriod] - } else { - break - } - } - - return f -} - -// getCaller retrieves the name of the first non-logrus calling function -func getCaller() *runtime.Frame { - - // cache this package's fully-qualified name - callerInitOnce.Do(func() { - pcs := make([]uintptr, 2) - _ = runtime.Callers(0, pcs) - logrusPackage = getPackageName(runtime.FuncForPC(pcs[1]).Name()) - - // now that we have the cache, we can skip a minimum count of known-logrus functions - // XXX this is dubious, the number of frames may vary - minimumCallerDepth = knownLogrusFrames - }) - - // Restrict the lookback frames to avoid runaway lookups - pcs := make([]uintptr, maximumCallerDepth) - depth := runtime.Callers(minimumCallerDepth, pcs) - frames := runtime.CallersFrames(pcs[:depth]) - - for f, again := frames.Next(); again; f, again = frames.Next() { - pkg := getPackageName(f.Function) - - // If the caller isn't part of this package, we're done - if pkg != logrusPackage { - return &f - } - } - - // if we got here, we failed to find the caller's context - return nil -} - -func (entry Entry) HasCaller() (has bool) { - return entry.Logger != nil && - entry.Logger.ReportCaller && - entry.Caller != nil -} - -// This function is not declared with a pointer value because otherwise -// race conditions will occur when using multiple goroutines -func (entry Entry) log(level Level, msg string) { - var buffer *bytes.Buffer - - // Default to now, but allow users to override if they want. - // - // We don't have to worry about polluting future calls to Entry#log() - // with this assignment because this function is declared with a - // non-pointer receiver. - if entry.Time.IsZero() { - entry.Time = time.Now() - } - - entry.Level = level - entry.Message = msg - if entry.Logger.ReportCaller { - entry.Caller = getCaller() - } - - entry.fireHooks() - - buffer = bufferPool.Get().(*bytes.Buffer) - buffer.Reset() - defer bufferPool.Put(buffer) - entry.Buffer = buffer - - entry.write() - - entry.Buffer = nil - - // To avoid Entry#log() returning a value that only would make sense for - // panic() to use in Entry#Panic(), we avoid the allocation by checking - // directly here. - if level <= PanicLevel { - panic(&entry) - } -} - -func (entry *Entry) fireHooks() { - entry.Logger.mu.Lock() - defer entry.Logger.mu.Unlock() - err := entry.Logger.Hooks.Fire(entry.Level, entry) - if err != nil { - fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err) - } -} - -func (entry *Entry) write() { - entry.Logger.mu.Lock() - defer entry.Logger.mu.Unlock() - serialized, err := entry.Logger.Formatter.Format(entry) - if err != nil { - fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err) - } else { - _, err = entry.Logger.Out.Write(serialized) - if err != nil { - fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err) - } - } -} - -func (entry *Entry) Log(level Level, args ...interface{}) { - if entry.Logger.IsLevelEnabled(level) { - entry.log(level, fmt.Sprint(args...)) - } -} - -func (entry *Entry) Trace(args ...interface{}) { - entry.Log(TraceLevel, args...) -} - -func (entry *Entry) Debug(args ...interface{}) { - entry.Log(DebugLevel, args...) -} - -func (entry *Entry) Print(args ...interface{}) { - entry.Info(args...) -} - -func (entry *Entry) Info(args ...interface{}) { - entry.Log(InfoLevel, args...) -} - -func (entry *Entry) Warn(args ...interface{}) { - entry.Log(WarnLevel, args...) -} - -func (entry *Entry) Warning(args ...interface{}) { - entry.Warn(args...) -} - -func (entry *Entry) Error(args ...interface{}) { - entry.Log(ErrorLevel, args...) -} - -func (entry *Entry) Fatal(args ...interface{}) { - entry.Log(FatalLevel, args...) - entry.Logger.Exit(1) -} - -func (entry *Entry) Panic(args ...interface{}) { - entry.Log(PanicLevel, args...) - panic(fmt.Sprint(args...)) -} - -// Entry Printf family functions - -func (entry *Entry) Logf(level Level, format string, args ...interface{}) { - if entry.Logger.IsLevelEnabled(level) { - entry.Log(level, fmt.Sprintf(format, args...)) - } -} - -func (entry *Entry) Tracef(format string, args ...interface{}) { - entry.Logf(TraceLevel, format, args...) -} - -func (entry *Entry) Debugf(format string, args ...interface{}) { - entry.Logf(DebugLevel, format, args...) -} - -func (entry *Entry) Infof(format string, args ...interface{}) { - entry.Logf(InfoLevel, format, args...) -} - -func (entry *Entry) Printf(format string, args ...interface{}) { - entry.Infof(format, args...) -} - -func (entry *Entry) Warnf(format string, args ...interface{}) { - entry.Logf(WarnLevel, format, args...) -} - -func (entry *Entry) Warningf(format string, args ...interface{}) { - entry.Warnf(format, args...) -} - -func (entry *Entry) Errorf(format string, args ...interface{}) { - entry.Logf(ErrorLevel, format, args...) -} - -func (entry *Entry) Fatalf(format string, args ...interface{}) { - entry.Logf(FatalLevel, format, args...) - entry.Logger.Exit(1) -} - -func (entry *Entry) Panicf(format string, args ...interface{}) { - entry.Logf(PanicLevel, format, args...) -} - -// Entry Println family functions - -func (entry *Entry) Logln(level Level, args ...interface{}) { - if entry.Logger.IsLevelEnabled(level) { - entry.Log(level, entry.sprintlnn(args...)) - } -} - -func (entry *Entry) Traceln(args ...interface{}) { - entry.Logln(TraceLevel, args...) -} - -func (entry *Entry) Debugln(args ...interface{}) { - entry.Logln(DebugLevel, args...) -} - -func (entry *Entry) Infoln(args ...interface{}) { - entry.Logln(InfoLevel, args...) -} - -func (entry *Entry) Println(args ...interface{}) { - entry.Infoln(args...) -} - -func (entry *Entry) Warnln(args ...interface{}) { - entry.Logln(WarnLevel, args...) -} - -func (entry *Entry) Warningln(args ...interface{}) { - entry.Warnln(args...) -} - -func (entry *Entry) Errorln(args ...interface{}) { - entry.Logln(ErrorLevel, args...) -} - -func (entry *Entry) Fatalln(args ...interface{}) { - entry.Logln(FatalLevel, args...) - entry.Logger.Exit(1) -} - -func (entry *Entry) Panicln(args ...interface{}) { - entry.Logln(PanicLevel, args...) -} - -// Sprintlnn => Sprint no newline. This is to get the behavior of how -// fmt.Sprintln where spaces are always added between operands, regardless of -// their type. Instead of vendoring the Sprintln implementation to spare a -// string allocation, we do the simplest thing. -func (entry *Entry) sprintlnn(args ...interface{}) string { - msg := fmt.Sprintln(args...) - return msg[:len(msg)-1] -} diff --git a/vendor/github.com/sirupsen/logrus/exported.go b/vendor/github.com/sirupsen/logrus/exported.go deleted file mode 100644 index 62fc2f2..0000000 --- a/vendor/github.com/sirupsen/logrus/exported.go +++ /dev/null @@ -1,225 +0,0 @@ -package logrus - -import ( - "context" - "io" - "time" -) - -var ( - // std is the name of the standard logger in stdlib `log` - std = New() -) - -func StandardLogger() *Logger { - return std -} - -// SetOutput sets the standard logger output. -func SetOutput(out io.Writer) { - std.SetOutput(out) -} - -// SetFormatter sets the standard logger formatter. -func SetFormatter(formatter Formatter) { - std.SetFormatter(formatter) -} - -// SetReportCaller sets whether the standard logger will include the calling -// method as a field. -func SetReportCaller(include bool) { - std.SetReportCaller(include) -} - -// SetLevel sets the standard logger level. -func SetLevel(level Level) { - std.SetLevel(level) -} - -// GetLevel returns the standard logger level. -func GetLevel() Level { - return std.GetLevel() -} - -// IsLevelEnabled checks if the log level of the standard logger is greater than the level param -func IsLevelEnabled(level Level) bool { - return std.IsLevelEnabled(level) -} - -// AddHook adds a hook to the standard logger hooks. -func AddHook(hook Hook) { - std.AddHook(hook) -} - -// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key. -func WithError(err error) *Entry { - return std.WithField(ErrorKey, err) -} - -// WithContext creates an entry from the standard logger and adds a context to it. -func WithContext(ctx context.Context) *Entry { - return std.WithContext(ctx) -} - -// WithField creates an entry from the standard logger and adds a field to -// it. If you want multiple fields, use `WithFields`. -// -// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal -// or Panic on the Entry it returns. -func WithField(key string, value interface{}) *Entry { - return std.WithField(key, value) -} - -// WithFields creates an entry from the standard logger and adds multiple -// fields to it. This is simply a helper for `WithField`, invoking it -// once for each field. -// -// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal -// or Panic on the Entry it returns. -func WithFields(fields Fields) *Entry { - return std.WithFields(fields) -} - -// WithTime creats an entry from the standard logger and overrides the time of -// logs generated with it. -// -// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal -// or Panic on the Entry it returns. -func WithTime(t time.Time) *Entry { - return std.WithTime(t) -} - -// Trace logs a message at level Trace on the standard logger. -func Trace(args ...interface{}) { - std.Trace(args...) -} - -// Debug logs a message at level Debug on the standard logger. -func Debug(args ...interface{}) { - std.Debug(args...) -} - -// Print logs a message at level Info on the standard logger. -func Print(args ...interface{}) { - std.Print(args...) -} - -// Info logs a message at level Info on the standard logger. -func Info(args ...interface{}) { - std.Info(args...) -} - -// Warn logs a message at level Warn on the standard logger. -func Warn(args ...interface{}) { - std.Warn(args...) -} - -// Warning logs a message at level Warn on the standard logger. -func Warning(args ...interface{}) { - std.Warning(args...) -} - -// Error logs a message at level Error on the standard logger. -func Error(args ...interface{}) { - std.Error(args...) -} - -// Panic logs a message at level Panic on the standard logger. -func Panic(args ...interface{}) { - std.Panic(args...) -} - -// Fatal logs a message at level Fatal on the standard logger then the process will exit with status set to 1. -func Fatal(args ...interface{}) { - std.Fatal(args...) -} - -// Tracef logs a message at level Trace on the standard logger. -func Tracef(format string, args ...interface{}) { - std.Tracef(format, args...) -} - -// Debugf logs a message at level Debug on the standard logger. -func Debugf(format string, args ...interface{}) { - std.Debugf(format, args...) -} - -// Printf logs a message at level Info on the standard logger. -func Printf(format string, args ...interface{}) { - std.Printf(format, args...) -} - -// Infof logs a message at level Info on the standard logger. -func Infof(format string, args ...interface{}) { - std.Infof(format, args...) -} - -// Warnf logs a message at level Warn on the standard logger. -func Warnf(format string, args ...interface{}) { - std.Warnf(format, args...) -} - -// Warningf logs a message at level Warn on the standard logger. -func Warningf(format string, args ...interface{}) { - std.Warningf(format, args...) -} - -// Errorf logs a message at level Error on the standard logger. -func Errorf(format string, args ...interface{}) { - std.Errorf(format, args...) -} - -// Panicf logs a message at level Panic on the standard logger. -func Panicf(format string, args ...interface{}) { - std.Panicf(format, args...) -} - -// Fatalf logs a message at level Fatal on the standard logger then the process will exit with status set to 1. -func Fatalf(format string, args ...interface{}) { - std.Fatalf(format, args...) -} - -// Traceln logs a message at level Trace on the standard logger. -func Traceln(args ...interface{}) { - std.Traceln(args...) -} - -// Debugln logs a message at level Debug on the standard logger. -func Debugln(args ...interface{}) { - std.Debugln(args...) -} - -// Println logs a message at level Info on the standard logger. -func Println(args ...interface{}) { - std.Println(args...) -} - -// Infoln logs a message at level Info on the standard logger. -func Infoln(args ...interface{}) { - std.Infoln(args...) -} - -// Warnln logs a message at level Warn on the standard logger. -func Warnln(args ...interface{}) { - std.Warnln(args...) -} - -// Warningln logs a message at level Warn on the standard logger. -func Warningln(args ...interface{}) { - std.Warningln(args...) -} - -// Errorln logs a message at level Error on the standard logger. -func Errorln(args ...interface{}) { - std.Errorln(args...) -} - -// Panicln logs a message at level Panic on the standard logger. -func Panicln(args ...interface{}) { - std.Panicln(args...) -} - -// Fatalln logs a message at level Fatal on the standard logger then the process will exit with status set to 1. -func Fatalln(args ...interface{}) { - std.Fatalln(args...) -} diff --git a/vendor/github.com/sirupsen/logrus/formatter.go b/vendor/github.com/sirupsen/logrus/formatter.go deleted file mode 100644 index 4088837..0000000 --- a/vendor/github.com/sirupsen/logrus/formatter.go +++ /dev/null @@ -1,78 +0,0 @@ -package logrus - -import "time" - -// Default key names for the default fields -const ( - defaultTimestampFormat = time.RFC3339 - FieldKeyMsg = "msg" - FieldKeyLevel = "level" - FieldKeyTime = "time" - FieldKeyLogrusError = "logrus_error" - FieldKeyFunc = "func" - FieldKeyFile = "file" -) - -// The Formatter interface is used to implement a custom Formatter. It takes an -// `Entry`. It exposes all the fields, including the default ones: -// -// * `entry.Data["msg"]`. The message passed from Info, Warn, Error .. -// * `entry.Data["time"]`. The timestamp. -// * `entry.Data["level"]. The level the entry was logged at. -// -// Any additional fields added with `WithField` or `WithFields` are also in -// `entry.Data`. Format is expected to return an array of bytes which are then -// logged to `logger.Out`. -type Formatter interface { - Format(*Entry) ([]byte, error) -} - -// This is to not silently overwrite `time`, `msg`, `func` and `level` fields when -// dumping it. If this code wasn't there doing: -// -// logrus.WithField("level", 1).Info("hello") -// -// Would just silently drop the user provided level. Instead with this code -// it'll logged as: -// -// {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."} -// -// It's not exported because it's still using Data in an opinionated way. It's to -// avoid code duplication between the two default formatters. -func prefixFieldClashes(data Fields, fieldMap FieldMap, reportCaller bool) { - timeKey := fieldMap.resolve(FieldKeyTime) - if t, ok := data[timeKey]; ok { - data["fields."+timeKey] = t - delete(data, timeKey) - } - - msgKey := fieldMap.resolve(FieldKeyMsg) - if m, ok := data[msgKey]; ok { - data["fields."+msgKey] = m - delete(data, msgKey) - } - - levelKey := fieldMap.resolve(FieldKeyLevel) - if l, ok := data[levelKey]; ok { - data["fields."+levelKey] = l - delete(data, levelKey) - } - - logrusErrKey := fieldMap.resolve(FieldKeyLogrusError) - if l, ok := data[logrusErrKey]; ok { - data["fields."+logrusErrKey] = l - delete(data, logrusErrKey) - } - - // If reportCaller is not set, 'func' will not conflict. - if reportCaller { - funcKey := fieldMap.resolve(FieldKeyFunc) - if l, ok := data[funcKey]; ok { - data["fields."+funcKey] = l - } - fileKey := fieldMap.resolve(FieldKeyFile) - if l, ok := data[fileKey]; ok { - data["fields."+fileKey] = l - } - } -} diff --git a/vendor/github.com/sirupsen/logrus/hooks.go b/vendor/github.com/sirupsen/logrus/hooks.go deleted file mode 100644 index 3f151cd..0000000 --- a/vendor/github.com/sirupsen/logrus/hooks.go +++ /dev/null @@ -1,34 +0,0 @@ -package logrus - -// A hook to be fired when logging on the logging levels returned from -// `Levels()` on your implementation of the interface. Note that this is not -// fired in a goroutine or a channel with workers, you should handle such -// functionality yourself if your call is non-blocking and you don't wish for -// the logging calls for levels returned from `Levels()` to block. -type Hook interface { - Levels() []Level - Fire(*Entry) error -} - -// Internal type for storing the hooks on a logger instance. -type LevelHooks map[Level][]Hook - -// Add a hook to an instance of logger. This is called with -// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface. -func (hooks LevelHooks) Add(hook Hook) { - for _, level := range hook.Levels() { - hooks[level] = append(hooks[level], hook) - } -} - -// Fire all the hooks for the passed level. Used by `entry.log` to fire -// appropriate hooks for a log entry. -func (hooks LevelHooks) Fire(level Level, entry *Entry) error { - for _, hook := range hooks[level] { - if err := hook.Fire(entry); err != nil { - return err - } - } - - return nil -} diff --git a/vendor/github.com/sirupsen/logrus/json_formatter.go b/vendor/github.com/sirupsen/logrus/json_formatter.go deleted file mode 100644 index 098a21a..0000000 --- a/vendor/github.com/sirupsen/logrus/json_formatter.go +++ /dev/null @@ -1,121 +0,0 @@ -package logrus - -import ( - "bytes" - "encoding/json" - "fmt" - "runtime" -) - -type fieldKey string - -// FieldMap allows customization of the key names for default fields. -type FieldMap map[fieldKey]string - -func (f FieldMap) resolve(key fieldKey) string { - if k, ok := f[key]; ok { - return k - } - - return string(key) -} - -// JSONFormatter formats logs into parsable json -type JSONFormatter struct { - // TimestampFormat sets the format used for marshaling timestamps. - TimestampFormat string - - // DisableTimestamp allows disabling automatic timestamps in output - DisableTimestamp bool - - // DataKey allows users to put all the log entry parameters into a nested dictionary at a given key. - DataKey string - - // FieldMap allows users to customize the names of keys for default fields. - // As an example: - // formatter := &JSONFormatter{ - // FieldMap: FieldMap{ - // FieldKeyTime: "@timestamp", - // FieldKeyLevel: "@level", - // FieldKeyMsg: "@message", - // FieldKeyFunc: "@caller", - // }, - // } - FieldMap FieldMap - - // CallerPrettyfier can be set by the user to modify the content - // of the function and file keys in the json data when ReportCaller is - // activated. If any of the returned value is the empty string the - // corresponding key will be removed from json fields. - CallerPrettyfier func(*runtime.Frame) (function string, file string) - - // PrettyPrint will indent all json logs - PrettyPrint bool -} - -// Format renders a single log entry -func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) { - data := make(Fields, len(entry.Data)+4) - for k, v := range entry.Data { - switch v := v.(type) { - case error: - // Otherwise errors are ignored by `encoding/json` - // https://github.com/sirupsen/logrus/issues/137 - data[k] = v.Error() - default: - data[k] = v - } - } - - if f.DataKey != "" { - newData := make(Fields, 4) - newData[f.DataKey] = data - data = newData - } - - prefixFieldClashes(data, f.FieldMap, entry.HasCaller()) - - timestampFormat := f.TimestampFormat - if timestampFormat == "" { - timestampFormat = defaultTimestampFormat - } - - if entry.err != "" { - data[f.FieldMap.resolve(FieldKeyLogrusError)] = entry.err - } - if !f.DisableTimestamp { - data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat) - } - data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message - data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String() - if entry.HasCaller() { - funcVal := entry.Caller.Function - fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line) - if f.CallerPrettyfier != nil { - funcVal, fileVal = f.CallerPrettyfier(entry.Caller) - } - if funcVal != "" { - data[f.FieldMap.resolve(FieldKeyFunc)] = funcVal - } - if fileVal != "" { - data[f.FieldMap.resolve(FieldKeyFile)] = fileVal - } - } - - var b *bytes.Buffer - if entry.Buffer != nil { - b = entry.Buffer - } else { - b = &bytes.Buffer{} - } - - encoder := json.NewEncoder(b) - if f.PrettyPrint { - encoder.SetIndent("", " ") - } - if err := encoder.Encode(data); err != nil { - return nil, fmt.Errorf("failed to marshal fields to JSON, %v", err) - } - - return b.Bytes(), nil -} diff --git a/vendor/github.com/sirupsen/logrus/logger.go b/vendor/github.com/sirupsen/logrus/logger.go deleted file mode 100644 index c0c0b1e..0000000 --- a/vendor/github.com/sirupsen/logrus/logger.go +++ /dev/null @@ -1,351 +0,0 @@ -package logrus - -import ( - "context" - "io" - "os" - "sync" - "sync/atomic" - "time" -) - -type Logger struct { - // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a - // file, or leave it default which is `os.Stderr`. You can also set this to - // something more adventurous, such as logging to Kafka. - Out io.Writer - // Hooks for the logger instance. These allow firing events based on logging - // levels and log entries. For example, to send errors to an error tracking - // service, log to StatsD or dump the core on fatal errors. - Hooks LevelHooks - // All log entries pass through the formatter before logged to Out. The - // included formatters are `TextFormatter` and `JSONFormatter` for which - // TextFormatter is the default. In development (when a TTY is attached) it - // logs with colors, but to a file it wouldn't. You can easily implement your - // own that implements the `Formatter` interface, see the `README` or included - // formatters for examples. - Formatter Formatter - - // Flag for whether to log caller info (off by default) - ReportCaller bool - - // The logging level the logger should log at. This is typically (and defaults - // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be - // logged. - Level Level - // Used to sync writing to the log. Locking is enabled by Default - mu MutexWrap - // Reusable empty entry - entryPool sync.Pool - // Function to exit the application, defaults to `os.Exit()` - ExitFunc exitFunc -} - -type exitFunc func(int) - -type MutexWrap struct { - lock sync.Mutex - disabled bool -} - -func (mw *MutexWrap) Lock() { - if !mw.disabled { - mw.lock.Lock() - } -} - -func (mw *MutexWrap) Unlock() { - if !mw.disabled { - mw.lock.Unlock() - } -} - -func (mw *MutexWrap) Disable() { - mw.disabled = true -} - -// Creates a new logger. Configuration should be set by changing `Formatter`, -// `Out` and `Hooks` directly on the default logger instance. You can also just -// instantiate your own: -// -// var log = &Logger{ -// Out: os.Stderr, -// Formatter: new(JSONFormatter), -// Hooks: make(LevelHooks), -// Level: logrus.DebugLevel, -// } -// -// It's recommended to make this a global instance called `log`. -func New() *Logger { - return &Logger{ - Out: os.Stderr, - Formatter: new(TextFormatter), - Hooks: make(LevelHooks), - Level: InfoLevel, - ExitFunc: os.Exit, - ReportCaller: false, - } -} - -func (logger *Logger) newEntry() *Entry { - entry, ok := logger.entryPool.Get().(*Entry) - if ok { - return entry - } - return NewEntry(logger) -} - -func (logger *Logger) releaseEntry(entry *Entry) { - entry.Data = map[string]interface{}{} - logger.entryPool.Put(entry) -} - -// Adds a field to the log entry, note that it doesn't log until you call -// Debug, Print, Info, Warn, Error, Fatal or Panic. It only creates a log entry. -// If you want multiple fields, use `WithFields`. -func (logger *Logger) WithField(key string, value interface{}) *Entry { - entry := logger.newEntry() - defer logger.releaseEntry(entry) - return entry.WithField(key, value) -} - -// Adds a struct of fields to the log entry. All it does is call `WithField` for -// each `Field`. -func (logger *Logger) WithFields(fields Fields) *Entry { - entry := logger.newEntry() - defer logger.releaseEntry(entry) - return entry.WithFields(fields) -} - -// Add an error as single field to the log entry. All it does is call -// `WithError` for the given `error`. -func (logger *Logger) WithError(err error) *Entry { - entry := logger.newEntry() - defer logger.releaseEntry(entry) - return entry.WithError(err) -} - -// Add a context to the log entry. -func (logger *Logger) WithContext(ctx context.Context) *Entry { - entry := logger.newEntry() - defer logger.releaseEntry(entry) - return entry.WithContext(ctx) -} - -// Overrides the time of the log entry. -func (logger *Logger) WithTime(t time.Time) *Entry { - entry := logger.newEntry() - defer logger.releaseEntry(entry) - return entry.WithTime(t) -} - -func (logger *Logger) Logf(level Level, format string, args ...interface{}) { - if logger.IsLevelEnabled(level) { - entry := logger.newEntry() - entry.Logf(level, format, args...) - logger.releaseEntry(entry) - } -} - -func (logger *Logger) Tracef(format string, args ...interface{}) { - logger.Logf(TraceLevel, format, args...) -} - -func (logger *Logger) Debugf(format string, args ...interface{}) { - logger.Logf(DebugLevel, format, args...) -} - -func (logger *Logger) Infof(format string, args ...interface{}) { - logger.Logf(InfoLevel, format, args...) -} - -func (logger *Logger) Printf(format string, args ...interface{}) { - entry := logger.newEntry() - entry.Printf(format, args...) - logger.releaseEntry(entry) -} - -func (logger *Logger) Warnf(format string, args ...interface{}) { - logger.Logf(WarnLevel, format, args...) -} - -func (logger *Logger) Warningf(format string, args ...interface{}) { - logger.Warnf(format, args...) -} - -func (logger *Logger) Errorf(format string, args ...interface{}) { - logger.Logf(ErrorLevel, format, args...) -} - -func (logger *Logger) Fatalf(format string, args ...interface{}) { - logger.Logf(FatalLevel, format, args...) - logger.Exit(1) -} - -func (logger *Logger) Panicf(format string, args ...interface{}) { - logger.Logf(PanicLevel, format, args...) -} - -func (logger *Logger) Log(level Level, args ...interface{}) { - if logger.IsLevelEnabled(level) { - entry := logger.newEntry() - entry.Log(level, args...) - logger.releaseEntry(entry) - } -} - -func (logger *Logger) Trace(args ...interface{}) { - logger.Log(TraceLevel, args...) -} - -func (logger *Logger) Debug(args ...interface{}) { - logger.Log(DebugLevel, args...) -} - -func (logger *Logger) Info(args ...interface{}) { - logger.Log(InfoLevel, args...) -} - -func (logger *Logger) Print(args ...interface{}) { - entry := logger.newEntry() - entry.Print(args...) - logger.releaseEntry(entry) -} - -func (logger *Logger) Warn(args ...interface{}) { - logger.Log(WarnLevel, args...) -} - -func (logger *Logger) Warning(args ...interface{}) { - logger.Warn(args...) -} - -func (logger *Logger) Error(args ...interface{}) { - logger.Log(ErrorLevel, args...) -} - -func (logger *Logger) Fatal(args ...interface{}) { - logger.Log(FatalLevel, args...) - logger.Exit(1) -} - -func (logger *Logger) Panic(args ...interface{}) { - logger.Log(PanicLevel, args...) -} - -func (logger *Logger) Logln(level Level, args ...interface{}) { - if logger.IsLevelEnabled(level) { - entry := logger.newEntry() - entry.Logln(level, args...) - logger.releaseEntry(entry) - } -} - -func (logger *Logger) Traceln(args ...interface{}) { - logger.Logln(TraceLevel, args...) -} - -func (logger *Logger) Debugln(args ...interface{}) { - logger.Logln(DebugLevel, args...) -} - -func (logger *Logger) Infoln(args ...interface{}) { - logger.Logln(InfoLevel, args...) -} - -func (logger *Logger) Println(args ...interface{}) { - entry := logger.newEntry() - entry.Println(args...) - logger.releaseEntry(entry) -} - -func (logger *Logger) Warnln(args ...interface{}) { - logger.Logln(WarnLevel, args...) -} - -func (logger *Logger) Warningln(args ...interface{}) { - logger.Warnln(args...) -} - -func (logger *Logger) Errorln(args ...interface{}) { - logger.Logln(ErrorLevel, args...) -} - -func (logger *Logger) Fatalln(args ...interface{}) { - logger.Logln(FatalLevel, args...) - logger.Exit(1) -} - -func (logger *Logger) Panicln(args ...interface{}) { - logger.Logln(PanicLevel, args...) -} - -func (logger *Logger) Exit(code int) { - runHandlers() - if logger.ExitFunc == nil { - logger.ExitFunc = os.Exit - } - logger.ExitFunc(code) -} - -//When file is opened with appending mode, it's safe to -//write concurrently to a file (within 4k message on Linux). -//In these cases user can choose to disable the lock. -func (logger *Logger) SetNoLock() { - logger.mu.Disable() -} - -func (logger *Logger) level() Level { - return Level(atomic.LoadUint32((*uint32)(&logger.Level))) -} - -// SetLevel sets the logger level. -func (logger *Logger) SetLevel(level Level) { - atomic.StoreUint32((*uint32)(&logger.Level), uint32(level)) -} - -// GetLevel returns the logger level. -func (logger *Logger) GetLevel() Level { - return logger.level() -} - -// AddHook adds a hook to the logger hooks. -func (logger *Logger) AddHook(hook Hook) { - logger.mu.Lock() - defer logger.mu.Unlock() - logger.Hooks.Add(hook) -} - -// IsLevelEnabled checks if the log level of the logger is greater than the level param -func (logger *Logger) IsLevelEnabled(level Level) bool { - return logger.level() >= level -} - -// SetFormatter sets the logger formatter. -func (logger *Logger) SetFormatter(formatter Formatter) { - logger.mu.Lock() - defer logger.mu.Unlock() - logger.Formatter = formatter -} - -// SetOutput sets the logger output. -func (logger *Logger) SetOutput(output io.Writer) { - logger.mu.Lock() - defer logger.mu.Unlock() - logger.Out = output -} - -func (logger *Logger) SetReportCaller(reportCaller bool) { - logger.mu.Lock() - defer logger.mu.Unlock() - logger.ReportCaller = reportCaller -} - -// ReplaceHooks replaces the logger hooks and returns the old ones -func (logger *Logger) ReplaceHooks(hooks LevelHooks) LevelHooks { - logger.mu.Lock() - oldHooks := logger.Hooks - logger.Hooks = hooks - logger.mu.Unlock() - return oldHooks -} diff --git a/vendor/github.com/sirupsen/logrus/logrus.go b/vendor/github.com/sirupsen/logrus/logrus.go deleted file mode 100644 index 8644761..0000000 --- a/vendor/github.com/sirupsen/logrus/logrus.go +++ /dev/null @@ -1,186 +0,0 @@ -package logrus - -import ( - "fmt" - "log" - "strings" -) - -// Fields type, used to pass to `WithFields`. -type Fields map[string]interface{} - -// Level type -type Level uint32 - -// Convert the Level to a string. E.g. PanicLevel becomes "panic". -func (level Level) String() string { - if b, err := level.MarshalText(); err == nil { - return string(b) - } else { - return "unknown" - } -} - -// ParseLevel takes a string level and returns the Logrus log level constant. -func ParseLevel(lvl string) (Level, error) { - switch strings.ToLower(lvl) { - case "panic": - return PanicLevel, nil - case "fatal": - return FatalLevel, nil - case "error": - return ErrorLevel, nil - case "warn", "warning": - return WarnLevel, nil - case "info": - return InfoLevel, nil - case "debug": - return DebugLevel, nil - case "trace": - return TraceLevel, nil - } - - var l Level - return l, fmt.Errorf("not a valid logrus Level: %q", lvl) -} - -// UnmarshalText implements encoding.TextUnmarshaler. -func (level *Level) UnmarshalText(text []byte) error { - l, err := ParseLevel(string(text)) - if err != nil { - return err - } - - *level = Level(l) - - return nil -} - -func (level Level) MarshalText() ([]byte, error) { - switch level { - case TraceLevel: - return []byte("trace"), nil - case DebugLevel: - return []byte("debug"), nil - case InfoLevel: - return []byte("info"), nil - case WarnLevel: - return []byte("warning"), nil - case ErrorLevel: - return []byte("error"), nil - case FatalLevel: - return []byte("fatal"), nil - case PanicLevel: - return []byte("panic"), nil - } - - return nil, fmt.Errorf("not a valid logrus level %d", level) -} - -// A constant exposing all logging levels -var AllLevels = []Level{ - PanicLevel, - FatalLevel, - ErrorLevel, - WarnLevel, - InfoLevel, - DebugLevel, - TraceLevel, -} - -// These are the different logging levels. You can set the logging level to log -// on your instance of logger, obtained with `logrus.New()`. -const ( - // PanicLevel level, highest level of severity. Logs and then calls panic with the - // message passed to Debug, Info, ... - PanicLevel Level = iota - // FatalLevel level. Logs and then calls `logger.Exit(1)`. It will exit even if the - // logging level is set to Panic. - FatalLevel - // ErrorLevel level. Logs. Used for errors that should definitely be noted. - // Commonly used for hooks to send errors to an error tracking service. - ErrorLevel - // WarnLevel level. Non-critical entries that deserve eyes. - WarnLevel - // InfoLevel level. General operational entries about what's going on inside the - // application. - InfoLevel - // DebugLevel level. Usually only enabled when debugging. Very verbose logging. - DebugLevel - // TraceLevel level. Designates finer-grained informational events than the Debug. - TraceLevel -) - -// Won't compile if StdLogger can't be realized by a log.Logger -var ( - _ StdLogger = &log.Logger{} - _ StdLogger = &Entry{} - _ StdLogger = &Logger{} -) - -// StdLogger is what your logrus-enabled library should take, that way -// it'll accept a stdlib logger and a logrus logger. There's no standard -// interface, this is the closest we get, unfortunately. -type StdLogger interface { - Print(...interface{}) - Printf(string, ...interface{}) - Println(...interface{}) - - Fatal(...interface{}) - Fatalf(string, ...interface{}) - Fatalln(...interface{}) - - Panic(...interface{}) - Panicf(string, ...interface{}) - Panicln(...interface{}) -} - -// The FieldLogger interface generalizes the Entry and Logger types -type FieldLogger interface { - WithField(key string, value interface{}) *Entry - WithFields(fields Fields) *Entry - WithError(err error) *Entry - - Debugf(format string, args ...interface{}) - Infof(format string, args ...interface{}) - Printf(format string, args ...interface{}) - Warnf(format string, args ...interface{}) - Warningf(format string, args ...interface{}) - Errorf(format string, args ...interface{}) - Fatalf(format string, args ...interface{}) - Panicf(format string, args ...interface{}) - - Debug(args ...interface{}) - Info(args ...interface{}) - Print(args ...interface{}) - Warn(args ...interface{}) - Warning(args ...interface{}) - Error(args ...interface{}) - Fatal(args ...interface{}) - Panic(args ...interface{}) - - Debugln(args ...interface{}) - Infoln(args ...interface{}) - Println(args ...interface{}) - Warnln(args ...interface{}) - Warningln(args ...interface{}) - Errorln(args ...interface{}) - Fatalln(args ...interface{}) - Panicln(args ...interface{}) - - // IsDebugEnabled() bool - // IsInfoEnabled() bool - // IsWarnEnabled() bool - // IsErrorEnabled() bool - // IsFatalEnabled() bool - // IsPanicEnabled() bool -} - -// Ext1FieldLogger (the first extension to FieldLogger) is superfluous, it is -// here for consistancy. Do not use. Use Logger or Entry instead. -type Ext1FieldLogger interface { - FieldLogger - Tracef(format string, args ...interface{}) - Trace(args ...interface{}) - Traceln(args ...interface{}) -} diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go deleted file mode 100644 index 2403de9..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_appengine.go +++ /dev/null @@ -1,11 +0,0 @@ -// +build appengine - -package logrus - -import ( - "io" -) - -func checkIfTerminal(w io.Writer) bool { - return true -} diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go b/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go deleted file mode 100644 index 3c4f43f..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_bsd.go +++ /dev/null @@ -1,13 +0,0 @@ -// +build darwin dragonfly freebsd netbsd openbsd - -package logrus - -import "golang.org/x/sys/unix" - -const ioctlReadTermios = unix.TIOCGETA - -func isTerminal(fd int) bool { - _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) - return err == nil -} - diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go b/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go deleted file mode 100644 index 97af92c..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_no_terminal.go +++ /dev/null @@ -1,11 +0,0 @@ -// +build js nacl plan9 - -package logrus - -import ( - "io" -) - -func checkIfTerminal(w io.Writer) bool { - return false -} diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go b/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go deleted file mode 100644 index 3293fb3..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_notappengine.go +++ /dev/null @@ -1,17 +0,0 @@ -// +build !appengine,!js,!windows,!nacl,!plan9 - -package logrus - -import ( - "io" - "os" -) - -func checkIfTerminal(w io.Writer) bool { - switch v := w.(type) { - case *os.File: - return isTerminal(int(v.Fd())) - default: - return false - } -} diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go b/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go deleted file mode 100644 index f6710b3..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_solaris.go +++ /dev/null @@ -1,11 +0,0 @@ -package logrus - -import ( - "golang.org/x/sys/unix" -) - -// IsTerminal returns true if the given file descriptor is a terminal. -func isTerminal(fd int) bool { - _, err := unix.IoctlGetTermio(fd, unix.TCGETA) - return err == nil -} diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_unix.go b/vendor/github.com/sirupsen/logrus/terminal_check_unix.go deleted file mode 100644 index 355dc96..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_unix.go +++ /dev/null @@ -1,13 +0,0 @@ -// +build linux aix - -package logrus - -import "golang.org/x/sys/unix" - -const ioctlReadTermios = unix.TCGETS - -func isTerminal(fd int) bool { - _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) - return err == nil -} - diff --git a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go b/vendor/github.com/sirupsen/logrus/terminal_check_windows.go deleted file mode 100644 index 572889d..0000000 --- a/vendor/github.com/sirupsen/logrus/terminal_check_windows.go +++ /dev/null @@ -1,34 +0,0 @@ -// +build !appengine,!js,windows - -package logrus - -import ( - "io" - "os" - "syscall" - - sequences "github.com/konsorten/go-windows-terminal-sequences" -) - -func initTerminal(w io.Writer) { - switch v := w.(type) { - case *os.File: - sequences.EnableVirtualTerminalProcessing(syscall.Handle(v.Fd()), true) - } -} - -func checkIfTerminal(w io.Writer) bool { - var ret bool - switch v := w.(type) { - case *os.File: - var mode uint32 - err := syscall.GetConsoleMode(syscall.Handle(v.Fd()), &mode) - ret = (err == nil) - default: - ret = false - } - if ret { - initTerminal(w) - } - return ret -} diff --git a/vendor/github.com/sirupsen/logrus/text_formatter.go b/vendor/github.com/sirupsen/logrus/text_formatter.go deleted file mode 100644 index e01587c..0000000 --- a/vendor/github.com/sirupsen/logrus/text_formatter.go +++ /dev/null @@ -1,295 +0,0 @@ -package logrus - -import ( - "bytes" - "fmt" - "os" - "runtime" - "sort" - "strings" - "sync" - "time" -) - -const ( - red = 31 - yellow = 33 - blue = 36 - gray = 37 -) - -var baseTimestamp time.Time - -func init() { - baseTimestamp = time.Now() -} - -// TextFormatter formats logs into text -type TextFormatter struct { - // Set to true to bypass checking for a TTY before outputting colors. - ForceColors bool - - // Force disabling colors. - DisableColors bool - - // Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/ - EnvironmentOverrideColors bool - - // Disable timestamp logging. useful when output is redirected to logging - // system that already adds timestamps. - DisableTimestamp bool - - // Enable logging the full timestamp when a TTY is attached instead of just - // the time passed since beginning of execution. - FullTimestamp bool - - // TimestampFormat to use for display when a full timestamp is printed - TimestampFormat string - - // The fields are sorted by default for a consistent output. For applications - // that log extremely frequently and don't use the JSON formatter this may not - // be desired. - DisableSorting bool - - // The keys sorting function, when uninitialized it uses sort.Strings. - SortingFunc func([]string) - - // Disables the truncation of the level text to 4 characters. - DisableLevelTruncation bool - - // QuoteEmptyFields will wrap empty fields in quotes if true - QuoteEmptyFields bool - - // Whether the logger's out is to a terminal - isTerminal bool - - // FieldMap allows users to customize the names of keys for default fields. - // As an example: - // formatter := &TextFormatter{ - // FieldMap: FieldMap{ - // FieldKeyTime: "@timestamp", - // FieldKeyLevel: "@level", - // FieldKeyMsg: "@message"}} - FieldMap FieldMap - - // CallerPrettyfier can be set by the user to modify the content - // of the function and file keys in the data when ReportCaller is - // activated. If any of the returned value is the empty string the - // corresponding key will be removed from fields. - CallerPrettyfier func(*runtime.Frame) (function string, file string) - - terminalInitOnce sync.Once -} - -func (f *TextFormatter) init(entry *Entry) { - if entry.Logger != nil { - f.isTerminal = checkIfTerminal(entry.Logger.Out) - } -} - -func (f *TextFormatter) isColored() bool { - isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows")) - - if f.EnvironmentOverrideColors { - if force, ok := os.LookupEnv("CLICOLOR_FORCE"); ok && force != "0" { - isColored = true - } else if ok && force == "0" { - isColored = false - } else if os.Getenv("CLICOLOR") == "0" { - isColored = false - } - } - - return isColored && !f.DisableColors -} - -// Format renders a single log entry -func (f *TextFormatter) Format(entry *Entry) ([]byte, error) { - data := make(Fields) - for k, v := range entry.Data { - data[k] = v - } - prefixFieldClashes(data, f.FieldMap, entry.HasCaller()) - keys := make([]string, 0, len(data)) - for k := range data { - keys = append(keys, k) - } - - var funcVal, fileVal string - - fixedKeys := make([]string, 0, 4+len(data)) - if !f.DisableTimestamp { - fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime)) - } - fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel)) - if entry.Message != "" { - fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg)) - } - if entry.err != "" { - fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError)) - } - if entry.HasCaller() { - if f.CallerPrettyfier != nil { - funcVal, fileVal = f.CallerPrettyfier(entry.Caller) - } else { - funcVal = entry.Caller.Function - fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line) - } - - if funcVal != "" { - fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc)) - } - if fileVal != "" { - fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile)) - } - } - - if !f.DisableSorting { - if f.SortingFunc == nil { - sort.Strings(keys) - fixedKeys = append(fixedKeys, keys...) - } else { - if !f.isColored() { - fixedKeys = append(fixedKeys, keys...) - f.SortingFunc(fixedKeys) - } else { - f.SortingFunc(keys) - } - } - } else { - fixedKeys = append(fixedKeys, keys...) - } - - var b *bytes.Buffer - if entry.Buffer != nil { - b = entry.Buffer - } else { - b = &bytes.Buffer{} - } - - f.terminalInitOnce.Do(func() { f.init(entry) }) - - timestampFormat := f.TimestampFormat - if timestampFormat == "" { - timestampFormat = defaultTimestampFormat - } - if f.isColored() { - f.printColored(b, entry, keys, data, timestampFormat) - } else { - - for _, key := range fixedKeys { - var value interface{} - switch { - case key == f.FieldMap.resolve(FieldKeyTime): - value = entry.Time.Format(timestampFormat) - case key == f.FieldMap.resolve(FieldKeyLevel): - value = entry.Level.String() - case key == f.FieldMap.resolve(FieldKeyMsg): - value = entry.Message - case key == f.FieldMap.resolve(FieldKeyLogrusError): - value = entry.err - case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller(): - value = funcVal - case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller(): - value = fileVal - default: - value = data[key] - } - f.appendKeyValue(b, key, value) - } - } - - b.WriteByte('\n') - return b.Bytes(), nil -} - -func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) { - var levelColor int - switch entry.Level { - case DebugLevel, TraceLevel: - levelColor = gray - case WarnLevel: - levelColor = yellow - case ErrorLevel, FatalLevel, PanicLevel: - levelColor = red - default: - levelColor = blue - } - - levelText := strings.ToUpper(entry.Level.String()) - if !f.DisableLevelTruncation { - levelText = levelText[0:4] - } - - // Remove a single newline if it already exists in the message to keep - // the behavior of logrus text_formatter the same as the stdlib log package - entry.Message = strings.TrimSuffix(entry.Message, "\n") - - caller := "" - if entry.HasCaller() { - funcVal := fmt.Sprintf("%s()", entry.Caller.Function) - fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line) - - if f.CallerPrettyfier != nil { - funcVal, fileVal = f.CallerPrettyfier(entry.Caller) - } - - if fileVal == "" { - caller = funcVal - } else if funcVal == "" { - caller = fileVal - } else { - caller = fileVal + " " + funcVal - } - } - - if f.DisableTimestamp { - fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message) - } else if !f.FullTimestamp { - fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message) - } else { - fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message) - } - for _, k := range keys { - v := data[k] - fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k) - f.appendValue(b, v) - } -} - -func (f *TextFormatter) needsQuoting(text string) bool { - if f.QuoteEmptyFields && len(text) == 0 { - return true - } - for _, ch := range text { - if !((ch >= 'a' && ch <= 'z') || - (ch >= 'A' && ch <= 'Z') || - (ch >= '0' && ch <= '9') || - ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') { - return true - } - } - return false -} - -func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) { - if b.Len() > 0 { - b.WriteByte(' ') - } - b.WriteString(key) - b.WriteByte('=') - f.appendValue(b, value) -} - -func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) { - stringVal, ok := value.(string) - if !ok { - stringVal = fmt.Sprint(value) - } - - if !f.needsQuoting(stringVal) { - b.WriteString(stringVal) - } else { - b.WriteString(fmt.Sprintf("%q", stringVal)) - } -} diff --git a/vendor/github.com/sirupsen/logrus/writer.go b/vendor/github.com/sirupsen/logrus/writer.go deleted file mode 100644 index 9e1f751..0000000 --- a/vendor/github.com/sirupsen/logrus/writer.go +++ /dev/null @@ -1,64 +0,0 @@ -package logrus - -import ( - "bufio" - "io" - "runtime" -) - -func (logger *Logger) Writer() *io.PipeWriter { - return logger.WriterLevel(InfoLevel) -} - -func (logger *Logger) WriterLevel(level Level) *io.PipeWriter { - return NewEntry(logger).WriterLevel(level) -} - -func (entry *Entry) Writer() *io.PipeWriter { - return entry.WriterLevel(InfoLevel) -} - -func (entry *Entry) WriterLevel(level Level) *io.PipeWriter { - reader, writer := io.Pipe() - - var printFunc func(args ...interface{}) - - switch level { - case TraceLevel: - printFunc = entry.Trace - case DebugLevel: - printFunc = entry.Debug - case InfoLevel: - printFunc = entry.Info - case WarnLevel: - printFunc = entry.Warn - case ErrorLevel: - printFunc = entry.Error - case FatalLevel: - printFunc = entry.Fatal - case PanicLevel: - printFunc = entry.Panic - default: - printFunc = entry.Print - } - - go entry.writerScanner(reader, printFunc) - runtime.SetFinalizer(writer, writerFinalizer) - - return writer -} - -func (entry *Entry) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) { - scanner := bufio.NewScanner(reader) - for scanner.Scan() { - printFunc(scanner.Text()) - } - if err := scanner.Err(); err != nil { - entry.Errorf("Error while reading from Writer: %s", err) - } - reader.Close() -} - -func writerFinalizer(writer *io.PipeWriter) { - writer.Close() -}