diff --git a/cmd/admission-webhook/main.go b/cmd/admission-webhook/main.go index e43ec37be..cd0f94e94 100644 --- a/cmd/admission-webhook/main.go +++ b/cmd/admission-webhook/main.go @@ -24,7 +24,6 @@ import ( "syscall" "github.com/go-kit/log" - "github.com/go-kit/log/level" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/collectors" "github.com/prometheus/client_golang/prometheus/collectors/version" @@ -61,7 +60,15 @@ func main() { return } - logger, err := logging.NewLogger(logConfig) + logger, err := logging.NewLoggerSlog(logConfig) + if err != nil { + stdlog.Fatal(err) + } + + // We're currently migrating our logging library from go-kit to slog. + // The go-kit logger is being removed in small PRs. For now, we are creating 2 loggers to avoid breaking changes and + // to have a smooth transition. + goKitLogger, err := logging.NewLogger(logConfig) if err != nil { stdlog.Fatal(err) } @@ -74,7 +81,7 @@ func main() { wg, ctx := errgroup.WithContext(ctx) mux := http.NewServeMux() - admit := admission.New(log.With(logger, "component", "admissionwebhook")) + admit := admission.New(log.With(goKitLogger, "component", "admissionwebhook")) admit.Register(mux) r := prometheus.NewRegistry() @@ -90,9 +97,9 @@ func main() { w.Write([]byte(`{"status":"up"}`)) }) - srv, err := server.NewServer(logger, &serverConfig, mux) + srv, err := server.NewServer(goKitLogger, &serverConfig, mux) if err != nil { - level.Error(logger).Log("msg", "failed to create web server", "err", err) + logger.Error("failed to create web server", "err", err) os.Exit(1) } @@ -105,17 +112,17 @@ func main() { select { case sig := <-term: - level.Info(logger).Log("msg", "Received signal, exiting gracefully...", "signal", sig.String()) + logger.Info("Received signal, exiting gracefully...", "signal", sig.String()) case <-ctx.Done(): } if err := srv.Shutdown(ctx); err != nil { - level.Warn(logger).Log("msg", "Server shutdown error", "err", err) + logger.Warn("Server shutdown error", "err", err) } cancel() if err := wg.Wait(); err != nil { - level.Warn(logger).Log("msg", "Unhandled error received. Exiting...", "err", err) + logger.Warn("Unhandled error received. Exiting...", "err", err) os.Exit(1) } } diff --git a/cmd/operator/main.go b/cmd/operator/main.go index 61d4ca569..9ca148577 100644 --- a/cmd/operator/main.go +++ b/cmd/operator/main.go @@ -19,6 +19,7 @@ import ( "flag" "fmt" stdlog "log" + "log/slog" "net/http" "net/http/pprof" "os" @@ -27,7 +28,6 @@ import ( "syscall" "github.com/go-kit/log" - "github.com/go-kit/log/level" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/collectors" versioncollector "github.com/prometheus/client_golang/prometheus/collectors/version" @@ -64,7 +64,7 @@ import ( // that the operator has enough permissions to manage the resource. func checkPrerequisites( ctx context.Context, - logger log.Logger, + logger *slog.Logger, kclient kubernetes.Interface, allowedNamespaces []string, groupVersion schema.GroupVersion, @@ -77,7 +77,7 @@ func checkPrerequisites( } if !installed { - level.Warn(logger).Log("msg", fmt.Sprintf("resource %q (group: %q) not installed in the cluster", resource, groupVersion)) + logger.Warn(fmt.Sprintf("resource %q (group: %q) not installed in the cluster", resource, groupVersion)) return false, nil } @@ -88,7 +88,7 @@ func checkPrerequisites( if !allowed { for _, reason := range errs { - level.Warn(logger).Log("msg", fmt.Sprintf("missing permission on resource %q (group: %q)", resource, groupVersion), "reason", reason) + logger.Warn(fmt.Sprintf("missing permission on resource %q (group: %q)", resource, groupVersion), "reason", reason) } return false, nil } @@ -193,32 +193,38 @@ func run(fs *flag.FlagSet) int { return 0 } - logger, err := logging.NewLogger(logConfig) + logger, err := logging.NewLoggerSlog(logConfig) + if err != nil { + stdlog.Fatal(err) + } + + // We're currently migrating our logging library from go-kit to slog. + // The go-kit logger is being removed in small PRs. For now, we are creating 2 loggers to avoid breaking changes and + // to have a smooth transition. + goKitLogger, err := logging.NewLogger(logConfig) if err != nil { stdlog.Fatal(err) } if err := cfg.Gates.UpdateFeatureGates(*featureGates.Map); err != nil { - level.Error(logger).Log("error", err) + logger.Error("", "error", err) return 1 } - level.Info(logger).Log("msg", "Starting Prometheus Operator", "version", version.Info()) - level.Info(logger).Log("build_context", version.BuildContext()) - level.Info(logger).Log("feature_gates", cfg.Gates.String()) + logger.Info("Starting Prometheus Operator", "version", version.Info(), "build_context", version.BuildContext(), "feature_gates", cfg.Gates.String()) goruntime.SetMaxProcs(logger) goruntime.SetMemLimit(logger, memlimitRatio) if len(cfg.Namespaces.AllowList) > 0 && len(cfg.Namespaces.DenyList) > 0 { - level.Error(logger).Log( - "msg", "--namespaces and --deny-namespaces are mutually exclusive, only one should be provided", + logger.Error( + "--namespaces and --deny-namespaces are mutually exclusive, only one should be provided", "namespaces", cfg.Namespaces.AllowList, "deny_namespaces", cfg.Namespaces.DenyList, ) return 1 } cfg.Namespaces.Finalize() - level.Info(logger).Log("msg", "namespaces filtering configuration ", "config", cfg.Namespaces.String()) + logger.Info("namespaces filtering configuration ", "config", cfg.Namespaces.String()) ctx, cancel := context.WithCancel(context.Background()) wg, ctx := errgroup.WithContext(ctx) @@ -233,26 +239,26 @@ func run(fs *flag.FlagSet) int { }) if err != nil { - level.Error(logger).Log("msg", "failed to create Kubernetes client configuration", "err", err) + logger.Error("failed to create Kubernetes client configuration", "err", err) cancel() return 1 } kclient, err := kubernetes.NewForConfig(restConfig) if err != nil { - level.Error(logger).Log("msg", "failed to create Kubernetes client", "err", err) + logger.Error("failed to create Kubernetes client", "err", err) cancel() return 1 } kubernetesVersion, err := kclient.Discovery().ServerVersion() if err != nil { - level.Error(logger).Log("msg", "failed to request Kubernetes server version", "err", err) + logger.Error("failed to request Kubernetes server version", "err", err) cancel() return 1 } cfg.KubernetesVersion = *kubernetesVersion - level.Info(logger).Log("msg", "connection established", "cluster-version", cfg.KubernetesVersion) + logger.Info("connection established", "cluster-version", cfg.KubernetesVersion) promControllerOptions := make([]prometheuscontroller.ControllerOptions, 0) // Check if we can read the storage classs @@ -271,7 +277,7 @@ func run(fs *flag.FlagSet) int { }, ) if err != nil { - level.Error(logger).Log("msg", "failed to check StorageClass support", "err", err) + logger.Error("failed to check StorageClass support", "err", err) cancel() return 1 } @@ -287,14 +293,14 @@ func run(fs *flag.FlagSet) int { Verbs: []string{"create", "patch"}, }) if err != nil { - level.Error(logger).Log("msg", "failed to check Events support", "err", err) + logger.Error("failed to check Events support", "err", err) cancel() return 1 } if !canEmitEvents { for _, reason := range reasons { - level.Warn(logger).Log("msg", "missing permission to emit events", "reason", reason) + logger.Warn("missing permission to emit events", "reason", reason) } } eventRecorderFactory := operator.NewEventRecorderFactory(canEmitEvents) @@ -314,7 +320,7 @@ func run(fs *flag.FlagSet) int { }, ) if err != nil { - level.Error(logger).Log("msg", "failed to check ScrapeConfig support", "err", err) + logger.Error("failed to check ScrapeConfig support", "err", err) cancel() return 1 } @@ -343,16 +349,16 @@ func run(fs *flag.FlagSet) int { }, ) if err != nil { - level.Error(logger).Log("msg", "failed to check Prometheus support", "err", err) + logger.Error("failed to check Prometheus support", "err", err) cancel() return 1 } var po *prometheuscontroller.Operator if prometheusSupported { - po, err = prometheuscontroller.New(ctx, restConfig, cfg, logger, r, eventRecorderFactory, promControllerOptions...) + po, err = prometheuscontroller.New(ctx, restConfig, cfg, goKitLogger, r, eventRecorderFactory, promControllerOptions...) if err != nil { - level.Error(logger).Log("msg", "instantiating prometheus controller failed", "err", err) + logger.Error("instantiating prometheus controller failed", "err", err) cancel() return 1 } @@ -379,7 +385,7 @@ func run(fs *flag.FlagSet) int { }, ) if err != nil { - level.Error(logger).Log("msg", "failed to check PrometheusAgent support", "err", err) + logger.Error("failed to check PrometheusAgent support", "err", err) cancel() return 1 } @@ -397,13 +403,13 @@ func run(fs *flag.FlagSet) int { Verbs: []string{"get", "list", "watch", "create", "update", "delete"}, }) if err != nil { - level.Error(logger).Log("msg", "failed to check permissions on DaemonSet resource", "err", err) + logger.Error("failed to check permissions on DaemonSet resource", "err", err) cancel() return 1 } if !allowed { for _, reason := range errs { - level.Error(logger).Log("msg", "missing permissions to manage Daemonset resource for Prometheus Agent", "reason", reason) + logger.Error("missing permissions to manage Daemonset resource for Prometheus Agent", "reason", reason) cancel() return 1 } @@ -412,9 +418,9 @@ func run(fs *flag.FlagSet) int { var pao *prometheusagentcontroller.Operator if prometheusAgentSupported { - pao, err = prometheusagentcontroller.New(ctx, restConfig, cfg, logger, r, scrapeConfigSupported, canReadStorageClass, eventRecorderFactory) + pao, err = prometheusagentcontroller.New(ctx, restConfig, cfg, goKitLogger, r, scrapeConfigSupported, canReadStorageClass, eventRecorderFactory) if err != nil { - level.Error(logger).Log("msg", "instantiating prometheus-agent controller failed", "err", err) + logger.Error("instantiating prometheus-agent controller failed", "err", err) cancel() return 1 } @@ -441,16 +447,16 @@ func run(fs *flag.FlagSet) int { }, ) if err != nil { - level.Error(logger).Log("msg", "failed to check Alertmanager support", "err", err) + logger.Error("failed to check Alertmanager support", "err", err) cancel() return 1 } var ao *alertmanagercontroller.Operator if alertmanagerSupported { - ao, err = alertmanagercontroller.New(ctx, restConfig, cfg, logger, r, canReadStorageClass, eventRecorderFactory) + ao, err = alertmanagercontroller.New(ctx, restConfig, cfg, goKitLogger, r, canReadStorageClass, eventRecorderFactory) if err != nil { - level.Error(logger).Log("msg", "instantiating alertmanager controller failed", "err", err) + logger.Error("instantiating alertmanager controller failed", "err", err) cancel() return 1 } @@ -477,16 +483,16 @@ func run(fs *flag.FlagSet) int { }, ) if err != nil { - level.Error(logger).Log("msg", "failed to check ThanosRuler support", "err", err) + logger.Error("failed to check ThanosRuler support", "err", err) cancel() return 1 } var to *thanoscontroller.Operator if thanosRulerSupported { - to, err = thanoscontroller.New(ctx, restConfig, cfg, logger, r, canReadStorageClass, eventRecorderFactory) + to, err = thanoscontroller.New(ctx, restConfig, cfg, goKitLogger, r, canReadStorageClass, eventRecorderFactory) if err != nil { - level.Error(logger).Log("msg", "instantiating thanos controller failed", "err", err) + logger.Error("instantiating thanos controller failed", "err", err) cancel() return 1 } @@ -495,7 +501,7 @@ func run(fs *flag.FlagSet) int { var kec *kubelet.Controller if kubeletObject != "" { if kec, err = kubelet.New( - log.With(logger, "component", "kubelet_endpoints"), + log.With(goKitLogger, "component", "kubelet_endpoints"), restConfig, r, kubeletObject, @@ -504,14 +510,14 @@ func run(fs *flag.FlagSet) int { cfg.Labels, nodeAddressPriority, ); err != nil { - level.Error(logger).Log("msg", "instantiating kubelet endpoints controller failed", "err", err) + logger.Error("instantiating kubelet endpoints controller failed", "err", err) cancel() return 1 } } if po == nil && pao == nil && ao == nil && to == nil && kec == nil { - level.Error(logger).Log("msg", "no controller can be started, check the RBAC permissions of the service account") + logger.Error("no controller can be started, check the RBAC permissions of the service account") cancel() return 1 } @@ -519,7 +525,7 @@ func run(fs *flag.FlagSet) int { // Setup the web server. mux := http.NewServeMux() - admit := admission.New(log.With(logger, "component", "admissionwebhook")) + admit := admission.New(log.With(goKitLogger, "component", "admissionwebhook")) admit.Register(mux) r.MustRegister( @@ -544,9 +550,9 @@ func run(fs *flag.FlagSet) int { w.WriteHeader(http.StatusOK) })) - srv, err := server.NewServer(logger, &serverConfig, mux) + srv, err := server.NewServer(goKitLogger, &serverConfig, mux) if err != nil { - level.Error(logger).Log("msg", "failed to create web server", "err", err) + logger.Error("failed to create web server", "err", err) cancel() return 1 } @@ -576,17 +582,17 @@ func run(fs *flag.FlagSet) int { select { case <-term: - level.Info(logger).Log("msg", "received SIGTERM, exiting gracefully...") + logger.Info("received SIGTERM, exiting gracefully...") case <-ctx.Done(): } if err := srv.Shutdown(ctx); err != nil { - level.Warn(logger).Log("msg", "server shutdown error", "err", err) + logger.Warn("server shutdown error", "err", err) } cancel() if err := wg.Wait(); err != nil { - level.Warn(logger).Log("msg", "unhandled error received. Exiting...", "err", err) + logger.Warn("unhandled error received. Exiting...", "err", err) return 1 } diff --git a/cmd/prometheus-config-reloader/main.go b/cmd/prometheus-config-reloader/main.go index a27ca80ac..5ba9477a3 100644 --- a/cmd/prometheus-config-reloader/main.go +++ b/cmd/prometheus-config-reloader/main.go @@ -29,7 +29,6 @@ import ( "time" "github.com/alecthomas/kingpin/v2" - "github.com/go-kit/log/level" "github.com/oklog/run" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/collectors" @@ -122,25 +121,32 @@ func main() { os.Exit(0) } - logger, err := logging.NewLogger(logConfig) + logger, err := logging.NewLoggerSlog(logConfig) + if err != nil { + stdlog.Fatal(err) + } + + // We're currently migrating our logging library from go-kit to slog. + // The go-kit logger is being removed in small PRs. For now, we are creating 2 loggers to avoid breaking changes and + // to have a smooth transition. + goKitLogger, err := logging.NewLogger(logConfig) if err != nil { stdlog.Fatal(err) } err = web.Validate(*webConfig) if err != nil { - level.Error(logger).Log("msg", "Unable to validate web configuration file", "err", err) + logger.Error("Unable to validate web configuration file", "err", err) os.Exit(2) } if createStatefulsetOrdinalFrom != nil { if err := createOrdinalEnvvar(*createStatefulsetOrdinalFrom); err != nil { - level.Warn(logger).Log("msg", fmt.Sprintf("Failed setting %s", statefulsetOrdinalEnvvar)) + logger.Warn(fmt.Sprintf("Failed setting %s", statefulsetOrdinalEnvvar)) } } - level.Info(logger).Log("msg", "Starting prometheus-config-reloader", "version", version.Info()) - level.Info(logger).Log("build_context", version.BuildContext()) + logger.Info("Starting prometheus-config-reloader", "version", version.Info(), "build_context", version.BuildContext()) goruntime.SetMaxProcs(logger) goruntime.SetMemLimit(logger, *memlimitRatio) @@ -176,7 +182,7 @@ func main() { } rel := reloader.New( - logger, + goKitLogger, r, &opts, ) @@ -198,11 +204,11 @@ func main() { srv := &http.Server{} g.Add(func() error { - level.Info(logger).Log("msg", "Starting web server for metrics", "listen", *listenAddress) + logger.Info("Starting web server for metrics", "listen", *listenAddress) return web.ListenAndServe(srv, &web.FlagConfig{ WebListenAddresses: &[]string{*listenAddress}, WebConfigFile: webConfig, - }, logger) + }, goKitLogger) }, func(error) { srv.Close() }) @@ -213,7 +219,7 @@ func main() { g.Add(func() error { select { case <-term: - level.Info(logger).Log("msg", "Received SIGTERM, exiting gracefully...") + logger.Info("Received SIGTERM, exiting gracefully...") case <-ctx.Done(): } @@ -221,7 +227,7 @@ func main() { }, func(error) {}) if err := g.Run(); err != nil { - level.Error(logger).Log("msg", "Failed to run", "err", err) + logger.Error("Failed to run", "err", err) os.Exit(1) } } diff --git a/internal/goruntime/cpu.go b/internal/goruntime/cpu.go index 03ff9bc7b..02153417b 100644 --- a/internal/goruntime/cpu.go +++ b/internal/goruntime/cpu.go @@ -16,19 +16,18 @@ package goruntime import ( "fmt" + "log/slog" "strings" - "github.com/go-kit/log" - "github.com/go-kit/log/level" "go.uber.org/automaxprocs/maxprocs" ) -func SetMaxProcs(logger log.Logger) { +func SetMaxProcs(logger *slog.Logger) { l := func(format string, a ...interface{}) { - level.Info(logger).Log("msg", fmt.Sprintf(strings.TrimPrefix(format, "maxprocs: "), a...)) + logger.Info(fmt.Sprintf(strings.TrimPrefix(format, "maxprocs: "), a...)) } if _, err := maxprocs.Set(maxprocs.Logger(l)); err != nil { - level.Warn(logger).Log("msg", "Failed to set GOMAXPROCS automatically", "err", err) + logger.Warn("Failed to set GOMAXPROCS automatically", "err", err) } } diff --git a/internal/goruntime/memory.go b/internal/goruntime/memory.go index 3088addf8..d646b1b76 100644 --- a/internal/goruntime/memory.go +++ b/internal/goruntime/memory.go @@ -15,14 +15,14 @@ package goruntime import ( + "fmt" + "log/slog" "runtime/debug" "github.com/KimMachineGun/automemlimit/memlimit" - "github.com/go-kit/log" - "github.com/go-kit/log/level" ) -func SetMemLimit(logger log.Logger, memlimitRatio float64) { +func SetMemLimit(logger *slog.Logger, memlimitRatio float64) { if memlimitRatio >= 1.0 { memlimitRatio = 1.0 } else if memlimitRatio <= 0.0 { @@ -43,8 +43,8 @@ func SetMemLimit(logger log.Logger, memlimitRatio float64) { ), ), ); err != nil { - level.Warn(logger).Log("component", "automemlimit", "msg", "Failed to set GOMEMLIMIT automatically", "err", err) + logger.Warn("Failed to set GOMEMLIMIT automatically", "component", "automemlimit", "err", err) } - level.Info(logger).Log("GOMEMLIMIT set to %d", debug.SetMemoryLimit(-1)) + logger.Info(fmt.Sprintf("GOMEMLIMIT set to %d", debug.SetMemoryLimit(-1))) }