From 3c8a018721044c3ced2eaa4c56f9ff9be3d94f31 Mon Sep 17 00:00:00 2001 From: Arthur Silva Sens Date: Mon, 9 Oct 2023 13:43:44 -0300 Subject: [PATCH] Enable depguard in prometheus pkg (#5973) Signed-off-by: Arthur Silva Sens --- .golangci.yml | 2 + pkg/prometheus/agent/operator.go | 77 ++++++++++---------- pkg/prometheus/agent/statefulset.go | 7 +- pkg/prometheus/operator.go | 7 +- pkg/prometheus/promcfg.go | 41 ++++++----- pkg/prometheus/resource_selector.go | 38 +++++----- pkg/prometheus/server/operator.go | 101 +++++++++++++-------------- pkg/prometheus/server/rules.go | 17 +++-- pkg/prometheus/server/statefulset.go | 11 ++- pkg/prometheus/statefulset.go | 3 +- pkg/prometheus/store.go | 26 ++++--- 11 files changed, 161 insertions(+), 169 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 95f52539f..0853366b7 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -42,6 +42,8 @@ linters-settings: - "**/listwatch/*.go" - "**/namespacelabeler/*.go" - "**/operator/*.go" + - "**/prometheus/*.go" + - "**/prometheus/**/*.go" deny: - pkg: "github.com/pkg/errors" dsc: Should be replaced with standard lib errors or fmt.Errorf \ No newline at end of file diff --git a/pkg/prometheus/agent/operator.go b/pkg/prometheus/agent/operator.go index c3158178c..fde6a0302 100644 --- a/pkg/prometheus/agent/operator.go +++ b/pkg/prometheus/agent/operator.go @@ -23,7 +23,6 @@ import ( "github.com/go-kit/log" "github.com/go-kit/log/level" "github.com/mitchellh/hashstructure" - "github.com/pkg/errors" "github.com/prometheus/client_golang/prometheus" appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" @@ -90,21 +89,21 @@ type Operator struct { func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, logger log.Logger, r prometheus.Registerer, scrapeConfigSupported bool, canReadStorageClass bool) (*Operator, error) { client, err := kubernetes.NewForConfig(restConfig) if err != nil { - return nil, errors.Wrap(err, "instantiating kubernetes client failed") + return nil, fmt.Errorf("instantiating kubernetes client failed: %w", err) } mclient, err := monitoringclient.NewForConfig(restConfig) if err != nil { - return nil, errors.Wrap(err, "instantiating monitoring client failed") + return nil, fmt.Errorf("instantiating monitoring client failed: %w", err) } if _, err := labels.Parse(conf.PromSelector); err != nil { - return nil, errors.Wrap(err, "can not parse prometheus-agent selector value") + return nil, fmt.Errorf("can not parse prometheus-agent selector value: %w", err) } secretListWatchSelector, err := fields.ParseSelector(conf.SecretListWatchSelector) if err != nil { - return nil, errors.Wrap(err, "can not parse secrets selector value") + return nil, fmt.Errorf("can not parse secrets selector value: %w", err) } // All the metrics exposed by the controller get the controller="prometheus-agent" label. @@ -145,7 +144,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1alpha1.SchemeGroupVersion.WithResource(monitoringv1alpha1.PrometheusAgentName), ) if err != nil { - return nil, errors.Wrap(err, "error creating prometheus-agent informers") + return nil, fmt.Errorf("error creating prometheus-agent informers: %w", err) } var promStores []cache.Store @@ -166,7 +165,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.ServiceMonitorName), ) if err != nil { - return nil, errors.Wrap(err, "error creating servicemonitor informers") + return nil, fmt.Errorf("error creating servicemonitor informers: %w", err) } c.pmonInfs, err = informers.NewInformersForResource( @@ -180,7 +179,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.PodMonitorName), ) if err != nil { - return nil, errors.Wrap(err, "error creating podmonitor informers") + return nil, fmt.Errorf("error creating podmonitor informers: %w", err) } c.probeInfs, err = informers.NewInformersForResource( @@ -194,7 +193,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.ProbeName), ) if err != nil { - return nil, errors.Wrap(err, "error creating probe informers") + return nil, fmt.Errorf("error creating probe informers: %w", err) } if c.scrapeConfigSupported { @@ -209,7 +208,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1alpha1.SchemeGroupVersion.WithResource(monitoringv1alpha1.ScrapeConfigName), ) if err != nil { - return nil, errors.Wrap(err, "error creating scrapeconfig informers") + return nil, fmt.Errorf("error creating scrapeconfig informers: %w", err) } } @@ -226,7 +225,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log v1.SchemeGroupVersion.WithResource(string(v1.ResourceConfigMaps)), ) if err != nil { - return nil, errors.Wrap(err, "error creating configmap informers") + return nil, fmt.Errorf("error creating configmap informers: %w", err) } c.secrInfs, err = informers.NewInformersForResource( @@ -242,7 +241,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log v1.SchemeGroupVersion.WithResource(string(v1.ResourceSecrets)), ) if err != nil { - return nil, errors.Wrap(err, "error creating secrets informers") + return nil, fmt.Errorf("error creating secrets informers: %w", err) } c.ssetInfs, err = informers.NewInformersForResource( @@ -256,7 +255,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log appsv1.SchemeGroupVersion.WithResource("statefulsets"), ) if err != nil { - return nil, errors.Wrap(err, "error creating statefulset informers") + return nil, fmt.Errorf("error creating statefulset informers: %w", err) } newNamespaceInformer := func(o *Operator, allowList map[string]struct{}) (cache.SharedIndexInformer, error) { @@ -390,7 +389,7 @@ func (c *Operator) waitForCacheSync(ctx context.Context) error { for _, inf := range infs.informersForResource.GetInformers() { if !operator.WaitForNamedCacheSync(ctx, "prometheusagent", log.With(c.logger, "informer", infs.name), inf.Informer()) { - return errors.Errorf("failed to sync cache for %s informer", infs.name) + return fmt.Errorf("failed to sync cache for %s informer", infs.name) } } } @@ -403,7 +402,7 @@ func (c *Operator) waitForCacheSync(ctx context.Context) error { {"MonNamespace", c.nsMonInf}, } { if !operator.WaitForNamedCacheSync(ctx, "prometheusagent", log.With(c.logger, "informer", inf.name), inf.informer) { - return errors.Errorf("failed to sync cache for %s informer", inf.name) + return fmt.Errorf("failed to sync cache for %s informer", inf.name) } } @@ -510,7 +509,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { p := pobj.(*monitoringv1alpha1.PrometheusAgent) p = p.DeepCopy() if err := k8sutil.AddTypeInformationToObject(p); err != nil { - return errors.Wrap(err, "failed to set Prometheus type information") + return fmt.Errorf("failed to set Prometheus type information: %w", err) } logger := log.With(c.logger, "key", key) @@ -538,22 +537,22 @@ func (c *Operator) sync(ctx context.Context, key string) error { assetStore := assets.NewStore(c.kclient.CoreV1(), c.kclient.CoreV1()) if err := c.createOrUpdateConfigurationSecret(ctx, p, cg, assetStore); err != nil { - return errors.Wrap(err, "creating config failed") + return fmt.Errorf("creating config failed: %w", err) } tlsAssets, err := c.createOrUpdateTLSAssetSecrets(ctx, p, assetStore) if err != nil { - return errors.Wrap(err, "creating tls asset secret failed") + return fmt.Errorf("creating tls asset secret failed: %w", err) } if err := c.createOrUpdateWebConfigSecret(ctx, p); err != nil { - return errors.Wrap(err, "synchronizing web config secret failed") + return fmt.Errorf("synchronizing web config secret failed: %w", err) } // Create governing service if it doesn't exist. svcClient := c.kclient.CoreV1().Services(p.Namespace) if err := k8sutil.CreateOrUpdateService(ctx, svcClient, makeStatefulSetService(p, c.config)); err != nil { - return errors.Wrap(err, "synchronizing governing service failed") + return fmt.Errorf("synchronizing governing service failed: %w", err) } ssetClient := c.kclient.AppsV1().StatefulSets(p.Namespace) @@ -567,7 +566,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { obj, err := c.ssetInfs.Get(prompkg.KeyToStatefulSetKey(p, key, shard)) exists := !apierrors.IsNotFound(err) if err != nil && !apierrors.IsNotFound(err) { - return errors.Wrap(err, "retrieving statefulset failed") + return fmt.Errorf("retrieving statefulset failed: %w", err) } existingStatefulSet := &appsv1.StatefulSet{} @@ -599,7 +598,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { int32(shard), tlsAssets.ShardNames()) if err != nil { - return errors.Wrap(err, "making statefulset failed") + return fmt.Errorf("making statefulset failed: %w", err) } operator.SanitizeSTS(sset) @@ -607,7 +606,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { level.Debug(logger).Log("msg", "no current statefulset found") level.Debug(logger).Log("msg", "creating statefulset") if _, err := ssetClient.Create(ctx, sset, metav1.CreateOptions{}); err != nil { - return errors.Wrap(err, "creating statefulset failed") + return fmt.Errorf("creating statefulset failed: %w", err) } continue } @@ -639,13 +638,13 @@ func (c *Operator) sync(ctx context.Context, key string) error { propagationPolicy := metav1.DeletePropagationForeground if err := ssetClient.Delete(ctx, sset.GetName(), metav1.DeleteOptions{PropagationPolicy: &propagationPolicy}); err != nil { - return errors.Wrap(err, "failed to delete StatefulSet to avoid forbidden action") + return fmt.Errorf("failed to delete StatefulSet to avoid forbidden action: %w", err) } continue } if err != nil { - return errors.Wrap(err, "updating StatefulSet failed") + return fmt.Errorf("updating StatefulSet failed: %w", err) } } @@ -673,7 +672,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { } }) if err != nil { - return errors.Wrap(err, "listing StatefulSet resources failed") + return fmt.Errorf("listing StatefulSet resources failed: %w", err) } return nil @@ -684,24 +683,24 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon smons, err := resourceSelector.SelectServiceMonitors(ctx, c.smonInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting ServiceMonitors failed") + return fmt.Errorf("selecting ServiceMonitors failed: %w", err) } pmons, err := resourceSelector.SelectPodMonitors(ctx, c.pmonInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting PodMonitors failed") + return fmt.Errorf("selecting PodMonitors failed: %w", err) } bmons, err := resourceSelector.SelectProbes(ctx, c.probeInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting Probes failed") + return fmt.Errorf("selecting Probes failed: %w", err) } var scrapeConfigs map[string]*monitoringv1alpha1.ScrapeConfig if c.sconInfs != nil { scrapeConfigs, err = resourceSelector.SelectScrapeConfigs(ctx, c.sconInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting ScrapeConfigs failed") + return fmt.Errorf("selecting ScrapeConfigs failed: %w", err) } } @@ -721,7 +720,7 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon additionalScrapeConfigs, err := c.loadConfigFromSecret(p.Spec.AdditionalScrapeConfigs, SecretsInPromNS) if err != nil { - return errors.Wrap(err, "loading additional scrape configs from Secret failed") + return fmt.Errorf("loading additional scrape configs from Secret failed: %w", err) } // Update secret based on the most recent configuration. @@ -735,13 +734,13 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon additionalScrapeConfigs, ) if err != nil { - return errors.Wrap(err, "generating config failed") + return fmt.Errorf("generating config failed: %w", err) } // Compress config to avoid 1mb secret limit for a while s, err := prompkg.MakeConfigurationSecret(p, c.config, conf) if err != nil { - return errors.Wrap(err, "creating compressed secret failed") + return fmt.Errorf("creating compressed secret failed: %w", err) } level.Debug(c.logger).Log("msg", "updating Prometheus configuration secret") @@ -779,7 +778,7 @@ func createSSetInputHash(p monitoringv1alpha1.PrometheusAgent, c operator.Config nil, ) if err != nil { - return "", errors.Wrap(err, "failed to calculate combined hash") + return "", fmt.Errorf("failed to calculate combined hash: %w", err) } return fmt.Sprintf("%d", hash), nil @@ -802,12 +801,12 @@ func (c *Operator) UpdateStatus(ctx context.Context, key string) error { pStatus, err := c.statusReporter.Process(ctx, p, key) if err != nil { - return errors.Wrap(err, "failed to get prometheus agent status") + return fmt.Errorf("failed to get prometheus agent status: %w", err) } p.Status = *pStatus if _, err = c.mclient.MonitoringV1alpha1().PrometheusAgents(p.Namespace).ApplyStatus(ctx, prompkg.ApplyConfigurationFromPrometheusAgent(p), metav1.ApplyOptions{FieldManager: operator.PrometheusOperatorFieldManager, Force: true}); err != nil { - return errors.Wrap(err, "failed to Apply prometheus agent status subresource") + return fmt.Errorf("failed to Apply prometheus agent status subresource: %w", err) } return nil @@ -826,7 +825,7 @@ func (c *Operator) createOrUpdateTLSAssetSecrets(ctx context.Context, p *monitor sClient := c.kclient.CoreV1().Secrets(p.Namespace) if err := sSecret.StoreSecrets(ctx, sClient); err != nil { - return nil, errors.Wrapf(err, "failed to create TLS assets secret for Prometheus") + return nil, fmt.Errorf("failed to create TLS assets secret for Prometheus: %w", err) } level.Debug(c.logger).Log("msg", "tls-asset secret: stored") @@ -848,7 +847,7 @@ func (c *Operator) createOrUpdateWebConfigSecret(ctx context.Context, p *monitor fields, ) if err != nil { - return errors.Wrap(err, "failed to initialize web config") + return fmt.Errorf("failed to initialize web config: %w", err) } secretClient := c.kclient.CoreV1().Secrets(p.Namespace) @@ -864,7 +863,7 @@ func (c *Operator) createOrUpdateWebConfigSecret(ctx context.Context, p *monitor secretLabels := c.config.Labels.Merge(prompkg.ManagedByOperatorLabels) if err := webConfig.CreateOrUpdateWebConfigSecret(ctx, secretClient, secretAnnotations, secretLabels, ownerReference); err != nil { - return errors.Wrap(err, "failed to reconcile web config secret") + return fmt.Errorf("failed to reconcile web config secret: %w", err) } return nil diff --git a/pkg/prometheus/agent/statefulset.go b/pkg/prometheus/agent/statefulset.go index c9159f643..7d79eba88 100644 --- a/pkg/prometheus/agent/statefulset.go +++ b/pkg/prometheus/agent/statefulset.go @@ -20,7 +20,6 @@ import ( "path" "strings" - "github.com/pkg/errors" appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -63,7 +62,7 @@ func makeStatefulSet( p.SetCommonPrometheusFields(cpf) spec, err := makeStatefulSetSpec(p, config, cg, shard, tlsAssetSecrets) if err != nil { - return nil, errors.Wrap(err, "make StatefulSet spec") + return nil, fmt.Errorf("make StatefulSet spec: %w", err) } boolTrue := true @@ -328,7 +327,7 @@ func makeStatefulSetSpec( initContainers, err := k8sutil.MergePatchContainers(operatorInitContainers, cpf.InitContainers) if err != nil { - return nil, errors.Wrap(err, "failed to merge init containers spec") + return nil, fmt.Errorf("failed to merge init containers spec: %w", err) } containerArgs, err := operator.BuildArgs(promArgs, cpf.AdditionalArgs) @@ -382,7 +381,7 @@ func makeStatefulSetSpec( containers, err := k8sutil.MergePatchContainers(operatorContainers, cpf.Containers) if err != nil { - return nil, errors.Wrap(err, "failed to merge containers spec") + return nil, fmt.Errorf("failed to merge containers spec: %w", err) } // PodManagementPolicy is set to Parallel to mitigate issues in kubernetes: https://github.com/kubernetes/kubernetes/issues/60164 diff --git a/pkg/prometheus/operator.go b/pkg/prometheus/operator.go index bb43fc676..a2799b876 100644 --- a/pkg/prometheus/operator.go +++ b/pkg/prometheus/operator.go @@ -23,7 +23,6 @@ import ( "strings" "time" - "github.com/pkg/errors" appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" @@ -117,7 +116,7 @@ func ValidateRemoteWriteSpec(spec monitoringv1.RemoteWriteSpec) error { } if len(nonNilFields) > 1 { - return errors.Errorf("%s can't be set at the same time, at most one of them must be defined", strings.Join(nonNilFields, " and ")) + return fmt.Errorf("%s can't be set at the same time, at most one of them must be defined", strings.Join(nonNilFields, " and ")) } return nil @@ -168,7 +167,7 @@ func (sr *StatusReporter) Process(ctx context.Context, p monitoringv1.Prometheus continue } - return nil, errors.Wrap(err, "failed to retrieve statefulset") + return nil, fmt.Errorf("failed to retrieve statefulset: %w", err) } sset := obj.(*appsv1.StatefulSet).DeepCopy() @@ -178,7 +177,7 @@ func (sr *StatusReporter) Process(ctx context.Context, p monitoringv1.Prometheus stsReporter, err := operator.NewStatefulSetReporter(ctx, sr.Kclient, sset) if err != nil { - return nil, errors.Wrap(err, "failed to retrieve statefulset state") + return nil, fmt.Errorf("failed to retrieve statefulset state: %w", err) } pStatus.Replicas += int32(len(stsReporter.Pods)) diff --git a/pkg/prometheus/promcfg.go b/pkg/prometheus/promcfg.go index 99b247fa4..3704e3e7a 100644 --- a/pkg/prometheus/promcfg.go +++ b/pkg/prometheus/promcfg.go @@ -25,7 +25,6 @@ import ( "github.com/blang/semver/v4" "github.com/go-kit/log" "github.com/go-kit/log/level" - "github.com/pkg/errors" "github.com/prometheus/common/model" "gopkg.in/yaml.v2" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -72,11 +71,11 @@ func NewConfigGenerator(logger log.Logger, p monitoringv1.PrometheusInterface, e promVersion := operator.StringValOrDefault(p.GetCommonPrometheusFields().Version, operator.DefaultPrometheusVersion) version, err := semver.ParseTolerant(promVersion) if err != nil { - return nil, errors.Wrap(err, "failed to parse Prometheus version") + return nil, fmt.Errorf("failed to parse Prometheus version: %w", err) } if version.Major != 2 { - return nil, errors.Wrap(err, fmt.Sprintf("unsupported Prometheus major version %s", version)) + return nil, fmt.Errorf("unsupported Prometheus major version %s: %w", version, err) } logger = log.WithSuffix(logger, "version", promVersion) @@ -430,15 +429,15 @@ func CompareScrapeTimeoutToScrapeInterval(scrapeTimeout, scrapeInterval monitori var err error if si, err = model.ParseDuration(string(scrapeInterval)); err != nil { - return errors.Wrapf(err, "invalid scrapeInterval %q", scrapeInterval) + return fmt.Errorf("invalid scrapeInterval %q: %w", scrapeInterval, err) } if st, err = model.ParseDuration(string(scrapeTimeout)); err != nil { - return errors.Wrapf(err, "invalid scrapeTimeout: %q", scrapeTimeout) + return fmt.Errorf("invalid scrapeTimeout: %q: %w", scrapeTimeout, err) } if st > si { - return errors.Errorf("scrapeTimeout %q greater than scrapeInterval %q", scrapeTimeout, scrapeInterval) + return fmt.Errorf("scrapeTimeout %q greater than scrapeInterval %q", scrapeTimeout, scrapeInterval) } return nil @@ -498,12 +497,12 @@ func (cg *ConfigGenerator) GenerateServerConfiguration( scrapeConfigs = cg.appendProbeConfigs(scrapeConfigs, probes, apiserverConfig, store, shards) scrapeConfigs, err := cg.appendScrapeConfigs(ctx, scrapeConfigs, sCons, store) if err != nil { - return nil, errors.Wrap(err, "generate scrape configs") + return nil, fmt.Errorf("generate scrape configs: %w", err) } scrapeConfigs, err = cg.appendAdditionalScrapeConfigs(scrapeConfigs, additionalScrapeConfigs, shards) if err != nil { - return nil, errors.Wrap(err, "generate additional scrape configs") + return nil, fmt.Errorf("generate additional scrape configs: %w", err) } cfg = append(cfg, yaml.MapItem{ Key: "scrape_configs", @@ -513,13 +512,13 @@ func (cg *ConfigGenerator) GenerateServerConfiguration( // Storage config cfg, err = cg.appendStorageSettingsConfig(cfg, exemplars, tsdb) if err != nil { - return nil, errors.Wrap(err, "generating storage_settings configuration failed") + return nil, fmt.Errorf("generating storage_settings configuration failed: %w", err) } // Alerting config cfg, err = cg.appendAlertingConfig(cfg, alerting, additionalAlertRelabelConfigs, additionalAlertManagerConfigs, store) if err != nil { - return nil, errors.Wrap(err, "generating alerting configuration failed") + return nil, fmt.Errorf("generating alerting configuration failed: %w", err) } // Remote write config @@ -536,7 +535,7 @@ func (cg *ConfigGenerator) GenerateServerConfiguration( tracingcfg, err := cg.generateTracingConfig() if err != nil { - return nil, errors.Wrap(err, "generating tracing configuration failed") + return nil, fmt.Errorf("generating tracing configuration failed: %w", err) } cfg = append(cfg, tracingcfg) @@ -593,7 +592,7 @@ func (cg *ConfigGenerator) appendAlertingConfig( var additionalAlertmanagerConfigsYaml []yaml.MapSlice if err := yaml.Unmarshal([]byte(additionalAlertmanagerConfigs), &additionalAlertmanagerConfigsYaml); err != nil { - return nil, errors.Wrap(err, "unmarshalling additional alertmanager configs failed") + return nil, fmt.Errorf("unmarshalling additional alertmanager configs failed") } alertmanagerConfigs = append(alertmanagerConfigs, additionalAlertmanagerConfigsYaml...) @@ -614,7 +613,7 @@ func (cg *ConfigGenerator) appendAlertingConfig( var additionalAlertRelabelConfigsYaml []yaml.MapSlice if err := yaml.Unmarshal([]byte(additionalAlertRelabelConfigs), &additionalAlertRelabelConfigsYaml); err != nil { - return nil, errors.Wrap(err, "unmarshalling additional alerting relabel configs failed") + return nil, fmt.Errorf("unmarshalling additional alerting relabel configs failed: %w", err) } alertRelabelConfigs = append(alertRelabelConfigs, additionalAlertRelabelConfigsYaml...) @@ -1617,7 +1616,7 @@ func (cg *ConfigGenerator) generateAdditionalScrapeConfigs( var additionalScrapeConfigsYaml []yaml.MapSlice err := yaml.Unmarshal([]byte(additionalScrapeConfigs), &additionalScrapeConfigsYaml) if err != nil { - return nil, errors.Wrap(err, "unmarshalling additional scrape configs failed") + return nil, fmt.Errorf("unmarshalling additional scrape configs failed: %w", err) } if shards == 1 { return additionalScrapeConfigsYaml, nil @@ -1635,12 +1634,12 @@ func (cg *ConfigGenerator) generateAdditionalScrapeConfigs( } values, ok := mapItem.Value.([]interface{}) if !ok { - return nil, errors.Wrap(err, "error parsing relabel configs") + return nil, fmt.Errorf("error parsing relabel configs: %w", err) } for _, value := range values { relabeling, ok := value.(yaml.MapSlice) if !ok { - return nil, errors.Wrap(err, "error parsing relabel config") + return nil, fmt.Errorf("error parsing relabel config: %w", err) } relabelings = append(relabelings, relabeling) } @@ -2166,12 +2165,12 @@ func (cg *ConfigGenerator) GenerateAgentConfiguration( scrapeConfigs = cg.appendProbeConfigs(scrapeConfigs, probes, apiserverConfig, store, shards) scrapeConfigs, err := cg.appendScrapeConfigs(ctx, scrapeConfigs, sCons, store) if err != nil { - return nil, errors.Wrap(err, "generate scrape configs") + return nil, fmt.Errorf("generate scrape configs: %w", err) } scrapeConfigs, err = cg.appendAdditionalScrapeConfigs(scrapeConfigs, additionalScrapeConfigs, shards) if err != nil { - return nil, errors.Wrap(err, "generate additional scrape configs") + return nil, fmt.Errorf("generate additional scrape configs: %w", err) } cfg = append(cfg, yaml.MapItem{ Key: "scrape_configs", @@ -2186,7 +2185,7 @@ func (cg *ConfigGenerator) GenerateAgentConfiguration( if cpf.TracingConfig != nil { tracingcfg, err := cg.generateTracingConfig() if err != nil { - return nil, errors.Wrap(err, "generating tracing configuration failed") + return nil, fmt.Errorf("generating tracing configuration failed: %w", err) } cfg = append(cfg, tracingcfg) @@ -2412,7 +2411,7 @@ func (cg *ConfigGenerator) generateScrapeConfig( }) if err != nil { - return cfg, errors.Wrapf(err, "failed to read %s secret %s", config.TokenRef.Name, jobName) + return cfg, fmt.Errorf("failed to read %s secret %s: %w", config.TokenRef.Name, jobName, err) } configs[i] = append(configs[i], yaml.MapItem{ @@ -2521,7 +2520,7 @@ func (cg *ConfigGenerator) generateScrapeConfig( }) if err != nil { - return cfg, errors.Wrapf(err, "failed to read %s secret %s", v.Name, jobName) + return cfg, fmt.Errorf("failed to read %s secret %s: %w", v.Name, jobName, err) } proxyConnectHeader[k] = value diff --git a/pkg/prometheus/resource_selector.go b/pkg/prometheus/resource_selector.go index f2b73b278..696279af1 100644 --- a/pkg/prometheus/resource_selector.go +++ b/pkg/prometheus/resource_selector.go @@ -16,6 +16,7 @@ package prometheus import ( "context" + "errors" "fmt" "regexp" "strings" @@ -24,7 +25,6 @@ import ( "github.com/blang/semver/v4" "github.com/go-kit/log" "github.com/go-kit/log/level" - "github.com/pkg/errors" "github.com/prometheus/common/model" "github.com/prometheus/prometheus/model/relabel" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -105,7 +105,7 @@ func (rs *ResourceSelector) SelectServiceMonitors(ctx context.Context, listFn Li } }) if err != nil { - return nil, errors.Wrapf(err, "failed to list service monitors in namespace %s", ns) + return nil, fmt.Errorf("failed to list service monitors in namespace %s: %w", ns, err) } } @@ -239,7 +239,7 @@ func validateRelabelConfig(p monitoringv1.PrometheusInterface, rc monitoringv1.R version, err := semver.ParseTolerant(promVersion) if err != nil { - return errors.Wrap(err, "failed to parse Prometheus version") + return fmt.Errorf("failed to parse Prometheus version: %w", err) } minimumVersionCaseActions := version.GTE(semver.MustParse("2.36.0")) @@ -250,41 +250,41 @@ func validateRelabelConfig(p monitoringv1.PrometheusInterface, rc monitoringv1.R action := strings.ToLower(rc.Action) if (action == string(relabel.Lowercase) || action == string(relabel.Uppercase)) && !minimumVersionCaseActions { - return errors.Errorf("%s relabel action is only supported from Prometheus version 2.36.0", rc.Action) + return fmt.Errorf("%s relabel action is only supported from Prometheus version 2.36.0", rc.Action) } if (action == string(relabel.KeepEqual) || action == string(relabel.DropEqual)) && !minimumVersionEqualActions { - return errors.Errorf("%s relabel action is only supported from Prometheus version 2.41.0", rc.Action) + return fmt.Errorf("%s relabel action is only supported from Prometheus version 2.41.0", rc.Action) } if _, err := relabel.NewRegexp(rc.Regex); err != nil { - return errors.Wrapf(err, "invalid regex %s for relabel configuration", rc.Regex) + return fmt.Errorf("invalid regex %s for relabel configuration: %w", rc.Regex, err) } if rc.Modulus == 0 && action == string(relabel.HashMod) { - return errors.Errorf("relabel configuration for hashmod requires non-zero modulus") + return fmt.Errorf("relabel configuration for hashmod requires non-zero modulus") } if (action == string(relabel.Replace) || action == string(relabel.HashMod) || action == string(relabel.Lowercase) || action == string(relabel.Uppercase) || action == string(relabel.KeepEqual) || action == string(relabel.DropEqual)) && rc.TargetLabel == "" { - return errors.Errorf("relabel configuration for %s action needs targetLabel value", rc.Action) + return fmt.Errorf("relabel configuration for %s action needs targetLabel value", rc.Action) } if (action == string(relabel.Replace) || action == string(relabel.Lowercase) || action == string(relabel.Uppercase) || action == string(relabel.KeepEqual) || action == string(relabel.DropEqual)) && !relabelTarget.MatchString(rc.TargetLabel) { - return errors.Errorf("%q is invalid 'target_label' for %s action", rc.TargetLabel, rc.Action) + return fmt.Errorf("%q is invalid 'target_label' for %s action", rc.TargetLabel, rc.Action) } if (action == string(relabel.Lowercase) || action == string(relabel.Uppercase) || action == string(relabel.KeepEqual) || action == string(relabel.DropEqual)) && !(rc.Replacement == relabel.DefaultRelabelConfig.Replacement || rc.Replacement == "") { - return errors.Errorf("'replacement' can not be set for %s action", rc.Action) + return fmt.Errorf("'replacement' can not be set for %s action", rc.Action) } if action == string(relabel.LabelMap) { if rc.Replacement != "" && !relabelTarget.MatchString(rc.Replacement) { - return errors.Errorf("%q is invalid 'replacement' for %s action", rc.Replacement, rc.Action) + return fmt.Errorf("%q is invalid 'replacement' for %s action", rc.Replacement, rc.Action) } } if action == string(relabel.HashMod) && !model.LabelName(rc.TargetLabel).IsValid() { - return errors.Errorf("%q is invalid 'target_label' for %s action", rc.TargetLabel, rc.Action) + return fmt.Errorf("%q is invalid 'target_label' for %s action", rc.TargetLabel, rc.Action) } if action == string(relabel.KeepEqual) || action == string(relabel.DropEqual) { @@ -295,7 +295,7 @@ func validateRelabelConfig(p monitoringv1.PrometheusInterface, rc monitoringv1.R rc.Separator == relabel.DefaultRelabelConfig.Separator) || !(rc.Replacement == relabel.DefaultRelabelConfig.Replacement || rc.Replacement == "") { - return errors.Errorf("%s action requires only 'source_labels' and `target_label`, and no other fields", rc.Action) + return fmt.Errorf("%s action requires only 'source_labels' and `target_label`, and no other fields", rc.Action) } } @@ -309,7 +309,7 @@ func validateRelabelConfig(p monitoringv1.PrometheusInterface, rc monitoringv1.R rc.Separator == relabel.DefaultRelabelConfig.Separator) || !(rc.Replacement == relabel.DefaultRelabelConfig.Replacement || rc.Replacement == "") { - return errors.Errorf("%s action requires only 'regex', and no other fields", rc.Action) + return fmt.Errorf("%s action requires only 'regex', and no other fields", rc.Action) } } return nil @@ -360,7 +360,7 @@ func (rs *ResourceSelector) SelectPodMonitors(ctx context.Context, listFn ListAl } }) if err != nil { - return nil, errors.Wrapf(err, "failed to list pod monitors in namespace %s", ns) + return nil, fmt.Errorf("failed to list pod monitors in namespace %s: %w", ns, err) } } @@ -483,7 +483,7 @@ func (rs *ResourceSelector) SelectProbes(ctx context.Context, listFn ListAllByNa } }) if err != nil { - return nil, errors.Wrapf(err, "failed to list probes in namespace %s", ns) + return nil, fmt.Errorf("failed to list probes in namespace %s: %w", ns, err) } } @@ -589,13 +589,13 @@ func validateProberURL(url string) error { hostPort := strings.Split(url, ":") if !govalidator.IsHost(hostPort[0]) { - return errors.Errorf("invalid host: %q", hostPort[0]) + return fmt.Errorf("invalid host: %q", hostPort[0]) } // handling cases with url specified as host:port if len(hostPort) > 1 { if !govalidator.IsPort(hostPort[1]) { - return errors.Errorf("invalid port: %q", hostPort[1]) + return fmt.Errorf("invalid port: %q", hostPort[1]) } } return nil @@ -645,7 +645,7 @@ func (rs *ResourceSelector) SelectScrapeConfigs(ctx context.Context, listFn List } }) if err != nil { - return nil, errors.Wrapf(err, "failed to list ScrapeConfigs in namespace %s", ns) + return nil, fmt.Errorf("failed to list ScrapeConfigs in namespace %s: %w", ns, err) } } diff --git a/pkg/prometheus/server/operator.go b/pkg/prometheus/server/operator.go index 772735099..50a6662a9 100644 --- a/pkg/prometheus/server/operator.go +++ b/pkg/prometheus/server/operator.go @@ -23,7 +23,6 @@ import ( "github.com/go-kit/log" "github.com/go-kit/log/level" "github.com/mitchellh/hashstructure" - "github.com/pkg/errors" "github.com/prometheus/client_golang/prometheus" appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" @@ -100,26 +99,26 @@ type Operator struct { func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, logger log.Logger, r prometheus.Registerer, scrapeConfigSupported bool, canReadStorageClass bool) (*Operator, error) { client, err := kubernetes.NewForConfig(restConfig) if err != nil { - return nil, errors.Wrap(err, "instantiating kubernetes client failed") + return nil, fmt.Errorf("instantiating kubernetes client failed: %w", err) } mdClient, err := metadata.NewForConfig(restConfig) if err != nil { - return nil, errors.Wrap(err, "instantiating metadata client failed") + return nil, fmt.Errorf("instantiating metadata client failed: %w", err) } mclient, err := monitoringclient.NewForConfig(restConfig) if err != nil { - return nil, errors.Wrap(err, "instantiating monitoring client failed") + return nil, fmt.Errorf("instantiating monitoring client failed: %w", err) } if _, err := labels.Parse(conf.PromSelector); err != nil { - return nil, errors.Wrap(err, "can not parse prometheus selector value") + return nil, fmt.Errorf("can not parse prometheus selector value: %w", err) } secretListWatchSelector, err := fields.ParseSelector(conf.SecretListWatchSelector) if err != nil { - return nil, errors.Wrap(err, "can not parse secrets selector value") + return nil, fmt.Errorf("can not parse secrets selector value: %w", err) } kubeletObjectName := "" @@ -194,7 +193,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.PrometheusName), ) if err != nil { - return nil, errors.Wrap(err, "error creating prometheus informers") + return nil, fmt.Errorf("error creating prometheus informers: %w", err) } var promStores []cache.Store @@ -214,7 +213,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.ServiceMonitorName), ) if err != nil { - return nil, errors.Wrap(err, "error creating servicemonitor informers") + return nil, fmt.Errorf("error creating servicemonitor informers: %w", err) } c.pmonInfs, err = informers.NewInformersForResource( @@ -228,7 +227,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.PodMonitorName), ) if err != nil { - return nil, errors.Wrap(err, "error creating podmonitor informers") + return nil, fmt.Errorf("error creating podmonitor informers: %w", err) } c.probeInfs, err = informers.NewInformersForResource( @@ -242,7 +241,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.ProbeName), ) if err != nil { - return nil, errors.Wrap(err, "error creating probe informers") + return nil, fmt.Errorf("error creating probe informers: %w", err) } if c.scrapeConfigSupported { @@ -257,7 +256,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1alpha1.SchemeGroupVersion.WithResource(monitoringv1alpha1.ScrapeConfigName), ) if err != nil { - return nil, errors.Wrap(err, "error creating scrapeconfigs informers") + return nil, fmt.Errorf("error creating scrapeconfigs informers: %w", err) } } c.ruleInfs, err = informers.NewInformersForResource( @@ -271,7 +270,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log monitoringv1.SchemeGroupVersion.WithResource(monitoringv1.PrometheusRuleName), ) if err != nil { - return nil, errors.Wrap(err, "error creating prometheusrule informers") + return nil, fmt.Errorf("error creating prometheusrule informers: %w", err) } c.cmapInfs, err = informers.NewInformersForResource( @@ -287,7 +286,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log v1.SchemeGroupVersion.WithResource(string(v1.ResourceConfigMaps)), ) if err != nil { - return nil, errors.Wrap(err, "error creating configmap informers") + return nil, fmt.Errorf("error creating configmap informers: %w", err) } c.secrInfs, err = informers.NewInformersForResource( @@ -303,7 +302,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log v1.SchemeGroupVersion.WithResource(string(v1.ResourceSecrets)), ) if err != nil { - return nil, errors.Wrap(err, "error creating secrets informers") + return nil, fmt.Errorf("error creating secrets informers: %w", err) } c.ssetInfs, err = informers.NewInformersForResource( @@ -317,7 +316,7 @@ func New(ctx context.Context, restConfig *rest.Config, conf operator.Config, log appsv1.SchemeGroupVersion.WithResource("statefulsets"), ) if err != nil { - return nil, errors.Wrap(err, "error creating statefulset informers") + return nil, fmt.Errorf("error creating statefulset informers: %w", err) } newNamespaceInformer := func(o *Operator, allowList map[string]struct{}) (cache.SharedIndexInformer, error) { @@ -399,7 +398,7 @@ func (c *Operator) waitForCacheSync(ctx context.Context) error { for _, inf := range infs.informersForResource.GetInformers() { if !operator.WaitForNamedCacheSync(ctx, "prometheus", log.With(c.logger, "informer", infs.name), inf.Informer()) { - return errors.Errorf("failed to sync cache for %s informer", infs.name) + return fmt.Errorf("failed to sync cache for %s informer", infs.name) } } } @@ -412,7 +411,7 @@ func (c *Operator) waitForCacheSync(ctx context.Context) error { {"MonNamespace", c.nsMonInf}, } { if !operator.WaitForNamedCacheSync(ctx, "prometheus", log.With(c.logger, "informer", inf.name), inf.informer) { - return errors.Errorf("failed to sync cache for %s informer", inf.name) + return fmt.Errorf("failed to sync cache for %s informer", inf.name) } } @@ -574,7 +573,7 @@ func getNodeAddresses(nodes *v1.NodeList) ([]v1.EndpointAddress, []error) { for _, n := range nodes.Items { address, _, err := nodeAddress(n) if err != nil { - errs = append(errs, errors.Wrapf(err, "failed to determine hostname for node (%s)", n.Name)) + errs = append(errs, fmt.Errorf("failed to determine hostname for node (%s): %w", n.Name, err)) continue } addresses = append(addresses, v1.EndpointAddress{ @@ -636,7 +635,7 @@ func (c *Operator) syncNodeEndpoints(ctx context.Context) error { nodes, err := c.kclient.CoreV1().Nodes().List(ctx, metav1.ListOptions{LabelSelector: c.config.KubeletSelector}) if err != nil { - return errors.Wrap(err, "listing nodes failed") + return fmt.Errorf("listing nodes failed: %w", err) } level.Debug(logger).Log("msg", "Nodes retrieved from the Kubernetes API", "num_nodes", len(nodes.Items)) @@ -684,13 +683,13 @@ func (c *Operator) syncNodeEndpoints(ctx context.Context) error { level.Debug(logger).Log("msg", "Updating Kubernetes service", "service", c.kubeletObjectName, "ns", c.kubeletObjectNamespace) err = k8sutil.CreateOrUpdateService(ctx, c.kclient.CoreV1().Services(c.kubeletObjectNamespace), svc) if err != nil { - return errors.Wrap(err, "synchronizing kubelet service object failed") + return fmt.Errorf("synchronizing kubelet service object failed: %w", err) } level.Debug(logger).Log("msg", "Updating Kubernetes endpoint", "endpoint", c.kubeletObjectName, "ns", c.kubeletObjectNamespace) err = k8sutil.CreateOrUpdateEndpoints(ctx, c.kclient.CoreV1().Endpoints(c.kubeletObjectNamespace), eps) if err != nil { - return errors.Wrap(err, "synchronizing kubelet endpoints object failed") + return fmt.Errorf("synchronizing kubelet endpoints object failed: %w", err) } return nil @@ -1160,7 +1159,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { p := pobj.(*monitoringv1.Prometheus) p = p.DeepCopy() if err := k8sutil.AddTypeInformationToObject(p); err != nil { - return errors.Wrap(err, "failed to set Prometheus type information") + return fmt.Errorf("failed to set Prometheus type information: %w", err) } logger := log.With(c.logger, "key", key) @@ -1193,22 +1192,22 @@ func (c *Operator) sync(ctx context.Context, key string) error { } if err := c.createOrUpdateConfigurationSecret(ctx, p, cg, ruleConfigMapNames, assetStore); err != nil { - return errors.Wrap(err, "creating config failed") + return fmt.Errorf("creating config failed: %w", err) } tlsAssets, err := c.createOrUpdateTLSAssetSecrets(ctx, p, assetStore) if err != nil { - return errors.Wrap(err, "creating tls asset secret failed") + return fmt.Errorf("creating tls asset secret failed: %w", err) } if err := c.createOrUpdateWebConfigSecret(ctx, p); err != nil { - return errors.Wrap(err, "synchronizing web config secret failed") + return fmt.Errorf("synchronizing web config secret failed: %w", err) } // Create governing service if it doesn't exist. svcClient := c.kclient.CoreV1().Services(p.Namespace) if err := k8sutil.CreateOrUpdateService(ctx, svcClient, makeStatefulSetService(p, c.config)); err != nil { - return errors.Wrap(err, "synchronizing governing service failed") + return fmt.Errorf("synchronizing governing service failed: %w", err) } ssetClient := c.kclient.AppsV1().StatefulSets(p.Namespace) @@ -1222,7 +1221,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { obj, err := c.ssetInfs.Get(prompkg.KeyToStatefulSetKey(p, key, shard)) exists := !apierrors.IsNotFound(err) if err != nil && !apierrors.IsNotFound(err) { - return errors.Wrap(err, "retrieving statefulset failed") + return fmt.Errorf("retrieving statefulset failed: %w", err) } existingStatefulSet := &appsv1.StatefulSet{} @@ -1265,7 +1264,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { int32(shard), tlsAssets.ShardNames()) if err != nil { - return errors.Wrap(err, "making statefulset failed") + return fmt.Errorf("making statefulset failed: %w", err) } operator.SanitizeSTS(sset) @@ -1273,7 +1272,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { level.Debug(logger).Log("msg", "no current statefulset found") level.Debug(logger).Log("msg", "creating statefulset") if _, err := ssetClient.Create(ctx, sset, metav1.CreateOptions{}); err != nil { - return errors.Wrap(err, "creating statefulset failed") + return fmt.Errorf("creating statefulset failed: %w", err) } continue } @@ -1305,13 +1304,13 @@ func (c *Operator) sync(ctx context.Context, key string) error { propagationPolicy := metav1.DeletePropagationForeground if err := ssetClient.Delete(ctx, sset.GetName(), metav1.DeleteOptions{PropagationPolicy: &propagationPolicy}); err != nil { - return errors.Wrap(err, "failed to delete StatefulSet to avoid forbidden action") + return fmt.Errorf("failed to delete StatefulSet to avoid forbidden action: %w", err) } continue } if err != nil { - return errors.Wrap(err, "updating StatefulSet failed") + return fmt.Errorf("updating StatefulSet failed: %w", err) } } @@ -1339,7 +1338,7 @@ func (c *Operator) sync(ctx context.Context, key string) error { } }) if err != nil { - return errors.Wrap(err, "listing StatefulSet resources failed") + return fmt.Errorf("listing StatefulSet resources failed: %w", err) } return nil @@ -1363,13 +1362,13 @@ func (c *Operator) UpdateStatus(ctx context.Context, key string) error { pStatus, err := c.statusReporter.Process(ctx, p, key) if err != nil { - return errors.Wrap(err, "failed to get prometheus status") + return fmt.Errorf("failed to get prometheus status: %w", err) } p.Status = *pStatus if _, err = c.mclient.MonitoringV1().Prometheuses(p.Namespace).ApplyStatus(ctx, prompkg.ApplyConfigurationFromPrometheus(p), metav1.ApplyOptions{FieldManager: operator.PrometheusOperatorFieldManager, Force: true}); err != nil { - return errors.Wrap(err, "failed to apply prometheus status subresource") + return fmt.Errorf("failed to apply prometheus status subresource: %w", err) } return nil @@ -1440,7 +1439,7 @@ func createSSetInputHash(p monitoringv1.Prometheus, c operator.Config, ruleConfi nil, ) if err != nil { - return "", errors.Wrap(err, "failed to calculate combined hash") + return "", fmt.Errorf("failed to calculate combined hash: %w", err) } return fmt.Sprintf("%d", hash), nil @@ -1489,13 +1488,13 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon // make an empty secret s, err := prompkg.MakeConfigurationSecret(p, c.config, nil) if err != nil { - return errors.Wrap(err, "generating empty config secret failed") + return fmt.Errorf("generating empty config secret failed: %w", err) } sClient := c.kclient.CoreV1().Secrets(p.Namespace) _, err = sClient.Get(ctx, s.Name, metav1.GetOptions{}) if apierrors.IsNotFound(err) { if _, err := c.kclient.CoreV1().Secrets(p.Namespace).Create(ctx, s, metav1.CreateOptions{}); err != nil && !apierrors.IsAlreadyExists(err) { - return errors.Wrap(err, "creating empty config file failed") + return fmt.Errorf("creating empty config file failed: %w", err) } } if !apierrors.IsNotFound(err) && err != nil { @@ -1509,24 +1508,24 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon smons, err := resourceSelector.SelectServiceMonitors(ctx, c.smonInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting ServiceMonitors failed") + return fmt.Errorf("selecting ServiceMonitors failed: %w", err) } pmons, err := resourceSelector.SelectPodMonitors(ctx, c.pmonInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting PodMonitors failed") + return fmt.Errorf("selecting PodMonitors failed: %w", err) } bmons, err := resourceSelector.SelectProbes(ctx, c.probeInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting Probes failed") + return fmt.Errorf("selecting Probes failed: %w", err) } var scrapeConfigs map[string]*monitoringv1alpha1.ScrapeConfig if c.sconInfs != nil { scrapeConfigs, err = resourceSelector.SelectScrapeConfigs(ctx, c.sconInfs.ListAllByNamespace) if err != nil { - return errors.Wrap(err, "selecting ScrapeConfigs failed") + return fmt.Errorf("selecting ScrapeConfigs failed: %w", err) } } @@ -1551,25 +1550,25 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon if p.Spec.Alerting != nil { for i, am := range p.Spec.Alerting.Alertmanagers { if err := store.AddBasicAuth(ctx, p.GetNamespace(), am.BasicAuth, fmt.Sprintf("alertmanager/auth/%d", i)); err != nil { - return errors.Wrapf(err, "alerting") + return fmt.Errorf("alerting: %w", err) } if err := store.AddSafeAuthorizationCredentials(ctx, p.GetNamespace(), am.Authorization, fmt.Sprintf("alertmanager/auth/%d", i)); err != nil { - return errors.Wrapf(err, "alerting") + return fmt.Errorf("alerting: %w", err) } } } additionalScrapeConfigs, err := c.loadConfigFromSecret(p.Spec.AdditionalScrapeConfigs, SecretsInPromNS) if err != nil { - return errors.Wrap(err, "loading additional scrape configs from Secret failed") + return fmt.Errorf("loading additional scrape configs from Secret failed: %w", err) } additionalAlertRelabelConfigs, err := c.loadConfigFromSecret(p.Spec.AdditionalAlertRelabelConfigs, SecretsInPromNS) if err != nil { - return errors.Wrap(err, "loading additional alert relabel configs from Secret failed") + return fmt.Errorf("loading additional alert relabel configs from Secret failed: %w", err) } additionalAlertManagerConfigs, err := c.loadConfigFromSecret(p.Spec.AdditionalAlertManagerConfigs, SecretsInPromNS) if err != nil { - return errors.Wrap(err, "loading additional alert manager configs from Secret failed") + return fmt.Errorf("loading additional alert manager configs from Secret failed: %w", err) } // Update secret based on the most recent configuration. @@ -1593,13 +1592,13 @@ func (c *Operator) createOrUpdateConfigurationSecret(ctx context.Context, p *mon ruleConfigMapNames, ) if err != nil { - return errors.Wrap(err, "generating config failed") + return fmt.Errorf("generating config failed: %w", err) } // Compress config to avoid 1mb secret limit for a while s, err := prompkg.MakeConfigurationSecret(p, c.config, conf) if err != nil { - return errors.Wrap(err, "creating compressed secret failed") + return fmt.Errorf("creating compressed secret failed: %w", err) } level.Debug(c.logger).Log("msg", "updating Prometheus configuration secret") @@ -1619,7 +1618,7 @@ func (c *Operator) createOrUpdateTLSAssetSecrets(ctx context.Context, p *monitor sClient := c.kclient.CoreV1().Secrets(p.Namespace) if err := sSecret.StoreSecrets(ctx, sClient); err != nil { - return nil, errors.Wrapf(err, "failed to create TLS assets secret for Prometheus") + return nil, fmt.Errorf("failed to create TLS assets secret for Prometheus: %w", err) } level.Debug(c.logger).Log("msg", "tls-asset secret: stored") @@ -1641,7 +1640,7 @@ func (c *Operator) createOrUpdateWebConfigSecret(ctx context.Context, p *monitor fields, ) if err != nil { - return errors.Wrap(err, "failed to initialize web config") + return fmt.Errorf("failed to initialize web config: %w", err) } secretClient := c.kclient.CoreV1().Secrets(p.Namespace) @@ -1657,7 +1656,7 @@ func (c *Operator) createOrUpdateWebConfigSecret(ctx context.Context, p *monitor secretLabels := c.config.Labels.Merge(prompkg.ManagedByOperatorLabels) if err := webConfig.CreateOrUpdateWebConfigSecret(ctx, secretClient, secretAnnotations, secretLabels, ownerReference); err != nil { - return errors.Wrap(err, "failed to reconcile web config secret") + return fmt.Errorf("failed to reconcile web config secret: %w", err) } return nil diff --git a/pkg/prometheus/server/rules.go b/pkg/prometheus/server/rules.go index 2b8efd4f1..013a0ca8d 100644 --- a/pkg/prometheus/server/rules.go +++ b/pkg/prometheus/server/rules.go @@ -24,7 +24,6 @@ import ( "github.com/go-kit/log" "github.com/go-kit/log/level" - "github.com/pkg/errors" v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -71,12 +70,12 @@ func (c *Operator) createOrUpdateRuleConfigMaps(ctx context.Context, p *monitori promRuleSelector, err := operator.NewPrometheusRuleSelector(operator.PrometheusFormat, promVersion, p.Spec.RuleSelector, nsLabeler, c.ruleInfs, logger) if err != nil { - return nil, errors.Wrap(err, "initializing PrometheusRules failed") + return nil, fmt.Errorf("initializing PrometheusRules failed: %w", err) } newRules, rejected, err := promRuleSelector.Select(namespaces) if err != nil { - return nil, errors.Wrap(err, "selecting PrometheusRules failed") + return nil, fmt.Errorf("selecting PrometheusRules failed: %w", err) } if pKey, ok := c.accessor.MetaNamespaceKey(p); ok { @@ -113,7 +112,7 @@ func (c *Operator) createOrUpdateRuleConfigMaps(ctx context.Context, p *monitori newConfigMaps, err := makeRulesConfigMaps(p, newRules) if err != nil { - return nil, errors.Wrap(err, "failed to make rules ConfigMaps") + return nil, fmt.Errorf("failed to make rules ConfigMaps: %w", err) } newConfigMapNames := []string{} @@ -130,7 +129,7 @@ func (c *Operator) createOrUpdateRuleConfigMaps(ctx context.Context, p *monitori for _, cm := range newConfigMaps { _, err = cClient.Create(ctx, &cm, metav1.CreateOptions{}) if err != nil { - return nil, errors.Wrapf(err, "failed to create ConfigMap '%v'", cm.Name) + return nil, fmt.Errorf("failed to create ConfigMap '%v': %w", cm.Name, err) } } return newConfigMapNames, nil @@ -141,7 +140,7 @@ func (c *Operator) createOrUpdateRuleConfigMaps(ctx context.Context, p *monitori for _, cm := range currentConfigMaps { err := cClient.Delete(ctx, cm.Name, metav1.DeleteOptions{}) if err != nil { - return nil, errors.Wrapf(err, "failed to delete current ConfigMap '%v'", cm.Name) + return nil, fmt.Errorf("failed to delete current ConfigMap '%v': %w", cm.Name, err) } } @@ -153,7 +152,7 @@ func (c *Operator) createOrUpdateRuleConfigMaps(ctx context.Context, p *monitori for _, cm := range newConfigMaps { _, err = cClient.Create(ctx, &cm, metav1.CreateOptions{}) if err != nil { - return nil, errors.Wrapf(err, "failed to create new ConfigMap '%v'", cm.Name) + return nil, fmt.Errorf("failed to create new ConfigMap '%v': %w", cm.Name, err) } } @@ -173,7 +172,7 @@ func (c *Operator) selectRuleNamespaces(p *monitoringv1.Prometheus) ([]string, e } else { ruleNamespaceSelector, err := metav1.LabelSelectorAsSelector(p.Spec.RuleNamespaceSelector) if err != nil { - return namespaces, errors.Wrap(err, "convert rule namespace label selector to selector") + return namespaces, fmt.Errorf("convert rule namespace label selector to selector: %w", err) } namespaces, err = operator.ListMatchingNamespaces(ruleNamespaceSelector, c.nsMonInf) @@ -204,7 +203,7 @@ func makeRulesConfigMaps(p *monitoringv1.Prometheus, ruleFiles map[string]string //check if none of the rule files is too large for a single ConfigMap for filename, file := range ruleFiles { if len(file) > maxConfigMapDataSize { - return nil, errors.Errorf( + return nil, fmt.Errorf( "rule file '%v' is too large for a single Kubernetes ConfigMap", filename, ) diff --git a/pkg/prometheus/server/statefulset.go b/pkg/prometheus/server/statefulset.go index adcb35a31..c1e6bbd61 100644 --- a/pkg/prometheus/server/statefulset.go +++ b/pkg/prometheus/server/statefulset.go @@ -21,7 +21,6 @@ import ( "strings" "github.com/blang/semver/v4" - "github.com/pkg/errors" appsv1 "k8s.io/api/apps/v1" v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -126,7 +125,7 @@ func makeStatefulSet( p.SetCommonPrometheusFields(cpf) spec, err := makeStatefulSetSpec(baseImage, tag, sha, retention, retentionSize, rules, query, allowOverlappingBlocks, enableAdminAPI, queryLogFile, thanos, disableCompaction, p, config, cg, shard, ruleConfigMapNames, tlsAssetSecrets) if err != nil { - return nil, errors.Wrap(err, "make StatefulSet spec") + return nil, fmt.Errorf("make StatefulSet spec: %w", err) } boolTrue := true @@ -430,7 +429,7 @@ func makeStatefulSetSpec( initContainers, err := k8sutil.MergePatchContainers(operatorInitContainers, cpf.InitContainers) if err != nil { - return nil, errors.Wrap(err, "failed to merge init containers spec") + return nil, fmt.Errorf("failed to merge init containers spec: %w", err) } containerArgs, err := operator.BuildArgs(promArgs, cpf.AdditionalArgs) @@ -484,7 +483,7 @@ func makeStatefulSetSpec( containers, err := k8sutil.MergePatchContainers(operatorContainers, cpf.Containers) if err != nil { - return nil, errors.Wrap(err, "failed to merge containers spec") + return nil, fmt.Errorf("failed to merge containers spec: %w", err) } // PodManagementPolicy is set to Parallel to mitigate issues in kubernetes: https://github.com/kubernetes/kubernetes/issues/60164 @@ -659,7 +658,7 @@ func createThanosContainer( operator.StringPtrValOrDefault(thanos.SHA, ""), ) if err != nil { - return nil, errors.Wrap(err, "failed to build image path") + return nil, fmt.Errorf("failed to build image path: %w", err) } var grpcBindAddress, httpBindAddress string @@ -789,7 +788,7 @@ func createThanosContainer( thanosVersion, err := semver.ParseTolerant(operator.StringPtrValOrDefault(thanos.Version, operator.DefaultThanosVersion)) if err != nil { - return nil, errors.Wrap(err, "failed to parse Thanos version") + return nil, fmt.Errorf("failed to parse Thanos version: %w", err) } if thanos.GetConfigTimeout != "" && thanosVersion.GTE(semver.MustParse("0.29.0")) { diff --git a/pkg/prometheus/statefulset.go b/pkg/prometheus/statefulset.go index 273d881f5..163437ad2 100644 --- a/pkg/prometheus/statefulset.go +++ b/pkg/prometheus/statefulset.go @@ -22,7 +22,6 @@ import ( "path/filepath" "strings" - "github.com/pkg/errors" v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" @@ -114,7 +113,7 @@ func prometheusNameByShard(p monitoringv1.PrometheusInterface, shard int32) stri func compress(data []byte) ([]byte, error) { var buf bytes.Buffer if err := operator.GzipConfig(&buf, data); err != nil { - return nil, errors.Wrap(err, "failed to gzip config") + return nil, fmt.Errorf("failed to gzip config: %w", err) } return buf.Bytes(), nil diff --git a/pkg/prometheus/store.go b/pkg/prometheus/store.go index 864d2d31a..018ed25c5 100644 --- a/pkg/prometheus/store.go +++ b/pkg/prometheus/store.go @@ -18,8 +18,6 @@ import ( "context" "fmt" - "github.com/pkg/errors" - monv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1" "github.com/prometheus-operator/prometheus-operator/pkg/assets" ) @@ -28,23 +26,23 @@ func AddRemoteWritesToStore(ctx context.Context, store *assets.Store, namespace for i, remote := range remotes { if err := ValidateRemoteWriteSpec(remote); err != nil { - return errors.Wrapf(err, "remote write %d", i) + return fmt.Errorf("remote write %d: %w", i, err) } key := fmt.Sprintf("remoteWrite/%d", i) if err := store.AddBasicAuth(ctx, namespace, remote.BasicAuth, key); err != nil { - return errors.Wrapf(err, "remote write %d", i) + return fmt.Errorf("remote write %d: %w", i, err) } if err := store.AddOAuth2(ctx, namespace, remote.OAuth2, key); err != nil { - return errors.Wrapf(err, "remote write %d", i) + return fmt.Errorf("remote write %d: %w", i, err) } if err := store.AddTLSConfig(ctx, namespace, remote.TLSConfig); err != nil { - return errors.Wrapf(err, "remote write %d", i) + return fmt.Errorf("remote write %d: %w", i, err) } if err := store.AddAuthorizationCredentials(ctx, namespace, remote.Authorization, fmt.Sprintf("remoteWrite/auth/%d", i)); err != nil { - return errors.Wrapf(err, "remote write %d", i) + return fmt.Errorf("remote write %d: %w", i, err) } if err := store.AddSigV4(ctx, namespace, remote.Sigv4, key); err != nil { - return errors.Wrapf(err, "remote write %d", i) + return fmt.Errorf("remote write %d: %w", i, err) } } return nil @@ -54,16 +52,16 @@ func AddRemoteReadsToStore(ctx context.Context, store *assets.Store, namespace s for i, remote := range remotes { if err := store.AddBasicAuth(ctx, namespace, remote.BasicAuth, fmt.Sprintf("remoteRead/%d", i)); err != nil { - return errors.Wrapf(err, "remote read %d", i) + return fmt.Errorf("remote read %d: %w", i, err) } if err := store.AddOAuth2(ctx, namespace, remote.OAuth2, fmt.Sprintf("remoteRead/%d", i)); err != nil { - return errors.Wrapf(err, "remote read %d", i) + return fmt.Errorf("remote read %d: %w", i, err) } if err := store.AddTLSConfig(ctx, namespace, remote.TLSConfig); err != nil { - return errors.Wrapf(err, "remote read %d", i) + return fmt.Errorf("remote read %d: %w", i, err) } if err := store.AddAuthorizationCredentials(ctx, namespace, remote.Authorization, fmt.Sprintf("remoteRead/auth/%d", i)); err != nil { - return errors.Wrapf(err, "remote read %d", i) + return fmt.Errorf("remote read %d: %w", i, err) } } return nil @@ -75,10 +73,10 @@ func AddAPIServerConfigToStore(ctx context.Context, store *assets.Store, namespa } if err := store.AddBasicAuth(ctx, namespace, config.BasicAuth, "apiserver"); err != nil { - return errors.Wrap(err, "apiserver config") + return fmt.Errorf("apiserver config: %w", err) } if err := store.AddAuthorizationCredentials(ctx, namespace, config.Authorization, "apiserver/auth"); err != nil { - return errors.Wrapf(err, "apiserver config") + return fmt.Errorf("apiserver config: %w", err) } return nil }