From a215aa81ebfe3a2a9ea8b600111671197919e906 Mon Sep 17 00:00:00 2001 From: Muhammad Talal Anwar Date: Tue, 25 Aug 2020 16:46:49 +0200 Subject: [PATCH] Minimize logging API --- internal/controller/controller.go | 6 ++--- internal/controller/prometheusrule.go | 6 ++--- internal/log/log.go | 37 ++++++++------------------- main.go | 31 +++++----------------- test/suite_test.go | 2 +- 5 files changed, 24 insertions(+), 58 deletions(-) diff --git a/internal/controller/controller.go b/internal/controller/controller.go index ecd1f4e0..2de747c4 100644 --- a/internal/controller/controller.go +++ b/internal/controller/controller.go @@ -196,7 +196,7 @@ func (c *Controller) enqueuePromRule(obj interface{}) { return } if mustParseBool(l[labelOperatorDisable]) { - c.logger.Info("msg", "operator disabled, skipping", "key", key) + c.logger.Debug("msg", "operator disabled, skipping", "key", key) return } @@ -272,7 +272,7 @@ func (c *Controller) processNextWorkItem() bool { // Finally, if no errors occurred we Forget this item so it does not // get queued again until another change happens. c.workqueue.Forget(obj) - c.logger.Info("msg", "sync successful", "key", key) + c.logger.Debug("msg", "sync successful", "key", key) return true } @@ -294,7 +294,7 @@ func (c *Controller) syncHandler(key string) error { case apierrors.IsNotFound(err): // The resource may no longer exist, in which case we clean up any // orphaned absent alerts. - c.logger.Info("msg", "PrometheusRule no longer exists", "key", key) + c.logger.Debug("msg", "PrometheusRule no longer exists", "key", key) err = c.cleanUpOrphanedAbsentAlertsNamespace(namespace, name) default: // Requeue object for later processing. diff --git a/internal/controller/prometheusrule.go b/internal/controller/prometheusrule.go index ee78b03d..9f31ff57 100644 --- a/internal/controller/prometheusrule.go +++ b/internal/controller/prometheusrule.go @@ -169,7 +169,7 @@ OuterLoop: return errors.Wrap(err, "could not update AbsentPrometheusRule") } - c.logger.Info("msg", "successfully updated absent metric alert rules", + c.logger.Debug("msg", "successfully updated absent metric alert rules", "key", fmt.Sprintf("%s/%s", absentPromRule.Namespace, absentPromRule.Name)) return nil } @@ -218,14 +218,14 @@ func (c *Controller) cleanUpOrphanedAbsentAlerts(promRuleName string, absentProm err = c.promClientset.MonitoringV1().PrometheusRules(absentPromRule.Namespace). Delete(context.Background(), absentPromRule.Name, metav1.DeleteOptions{}) if err == nil { - c.logger.Info("msg", "successfully deleted orphaned AbsentPrometheusRule", + c.logger.Debug("msg", "successfully deleted orphaned AbsentPrometheusRule", "key", fmt.Sprintf("%s/%s", absentPromRule.Namespace, absentPromRule.Name)) } } else { _, err = c.promClientset.MonitoringV1().PrometheusRules(absentPromRule.Namespace). Update(context.Background(), absentPromRule.PrometheusRule, metav1.UpdateOptions{}) if err == nil { - c.logger.Info("msg", "successfully cleaned up orphaned absent metric alert rules", + c.logger.Debug("msg", "successfully cleaned up orphaned absent metric alert rules", "key", fmt.Sprintf("%s/%s", absentPromRule.Namespace, absentPromRule.Name)) } } diff --git a/internal/log/log.go b/internal/log/log.go index b8c7a464..98428934 100644 --- a/internal/log/log.go +++ b/internal/log/log.go @@ -15,7 +15,6 @@ package log import ( - "fmt" "io" "os" @@ -23,16 +22,6 @@ import ( gokitlevel "github.com/go-kit/kit/log/level" ) -// Different types of log Level. -const ( - LevelAll = "all" - LevelDebug = "debug" - LevelInfo = "info" - LevelWarn = "warn" - LevelError = "error" - LevelNone = "none" -) - // Different types of log Format. const ( FormatLogfmt = "logfmt" @@ -46,41 +35,35 @@ type Logger struct { } // New returns a new Logger. -func New(w io.Writer, format, lvl string) (*Logger, error) { +func New(w io.Writer, format string, debug bool) *Logger { sw := gokitlog.NewSyncWriter(w) l := gokitlog.NewLogfmtLogger(sw) if format == FormatJSON { l = gokitlog.NewJSONLogger(sw) } - switch lvl { - case LevelAll: - l = gokitlevel.NewFilter(l, gokitlevel.AllowAll()) - case LevelDebug: + if debug { l = gokitlevel.NewFilter(l, gokitlevel.AllowDebug()) - case LevelInfo: + } else { l = gokitlevel.NewFilter(l, gokitlevel.AllowInfo()) - case LevelWarn: - l = gokitlevel.NewFilter(l, gokitlevel.AllowWarn()) - case LevelError: - l = gokitlevel.NewFilter(l, gokitlevel.AllowError()) - case LevelNone: - l = gokitlevel.NewFilter(l, gokitlevel.AllowNone()) - default: - return nil, fmt.Errorf("unexpected value for log level: %q, see --help", lvl) } l = gokitlog.With(l, "ts", gokitlog.DefaultTimestampUTC, "caller", gokitlog.Caller(4), ) - return &Logger{l}, nil + return &Logger{l} } // With returns a new contextual logger with keyvals prepended to those passed // to calls to Log. -func With(l Logger, keyvals ...interface{}) *Logger { +func With(l *Logger, keyvals ...interface{}) *Logger { return &Logger{gokitlog.With(l.Logger, keyvals...)} } +// Debug logs at the debug level. +func (l *Logger) Debug(keyvals ...interface{}) { + gokitlevel.Debug(l.Logger).Log(keyvals...) +} + // Info logs at the info level. func (l *Logger) Info(keyvals ...interface{}) { gokitlevel.Info(l.Logger).Log(keyvals...) diff --git a/main.go b/main.go index 88435775..f49c6f87 100644 --- a/main.go +++ b/main.go @@ -40,14 +40,6 @@ var ( ) var ( - availableLogLevels = []string{ - log.LevelAll, - log.LevelDebug, - log.LevelInfo, - log.LevelWarn, - log.LevelError, - log.LevelNone, - } availableLogFormats = []string{ log.FormatLogfmt, log.FormatJSON, @@ -59,24 +51,21 @@ var ( ) func main() { - var logLevel, logFormat, kubeconfig, keepLabels string + var debug bool + var logFormat, kubeconfig, keepLabels string flagset := flag.CommandLine - flagset.StringVar(&logLevel, "log-level", log.LevelInfo, - fmt.Sprintf("Log level to use. Possible values: %s", strings.Join(availableLogLevels, ", "))) + flagset.BoolVar(&debug, "debug", false, "Print debug level logs") flagset.StringVar(&logFormat, "log-format", log.FormatLogfmt, fmt.Sprintf("Log format to use. Possible values: %s", strings.Join(availableLogFormats, ", "))) flagset.StringVar(&kubeconfig, "kubeconfig", "", "Path to a kubeconfig. Only required if out-of-cluster") flagset.StringVar(&keepLabels, "keep-labels", strings.Join(defaultKeepLabels, ","), "A comma separated list of labels to keep from the original alert rule") if err := flagset.Parse(os.Args[1:]); err != nil { - logFatalf("could not parse flagset: %s", err.Error()) - } - - logger, err := log.New(os.Stdout, logFormat, logLevel) - if err != nil { - logFatalf(err.Error()) + fmt.Fprintf(os.Stderr, "FATAL: could not parse flagset: %s", err.Error()) + os.Exit(1) } + logger := log.New(os.Stdout, logFormat, debug) logger.Info("msg", "starting absent-metrics-operator", "version", version, "git-commit", commit, "build-date", date) @@ -98,7 +87,7 @@ func main() { if err != nil { logger.Fatal("msg", "instantiating cluster config failed", "err", err) } - c, err := controller.New(cfg, controller.DefaultResyncPeriod, r, keepLabelMap, log.With(*logger, "component", "controller")) + c, err := controller.New(cfg, controller.DefaultResyncPeriod, r, keepLabelMap, log.With(logger, "component", "controller")) if err != nil { logger.Fatal("msg", "could not instantiate controller", "err", err) } @@ -123,12 +112,6 @@ func main() { } } -// logFatalf is used when there is no log.Logger. -func logFatalf(format string, a ...interface{}) { - fmt.Fprintf(os.Stderr, "FATAL: "+format+"\n", a...) - os.Exit(1) -} - func landingPageHandler(logger *log.Logger) func(w http.ResponseWriter, r *http.Request) { return func(w http.ResponseWriter, r *http.Request) { pageBytes := []byte(` diff --git a/test/suite_test.go b/test/suite_test.go index 33290281..df74b00e 100644 --- a/test/suite_test.go +++ b/test/suite_test.go @@ -85,7 +85,7 @@ var _ = BeforeSuite(func() { // queued by the controller sequentially and we depend on this behavior in // our mock assertion. By("starting controller") - l, err := log.New(GinkgoWriter, log.FormatLogfmt, log.LevelAll) + l := log.New(GinkgoWriter, log.FormatLogfmt, true) Expect(err).ToNot(HaveOccurred()) kL := map[string]bool{ controller.LabelTier: true,