coreos/prometheus-operator
1
0
Fork 0
mirror of https://github.com/coreos/prometheus-operator.git synced 2026-02-05 06:45:27 +01:00
Code Issues Releases Wiki Activity

Enable depguard in prometheus pkg (#5973)

Browse Source 
Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>
This commit is contained in:
Arthur Silva Sens
2023-10-09 13:43:44 -03:00
committed by GitHub
parent b272f56545
commit 3c8a018721
11 changed files with 161 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.golangci.yml
View File

@@ -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

77
pkg/prometheus/agent/operator.go
View File

@@ -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

7
pkg/prometheus/agent/statefulset.go
View File

@@ -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

7
pkg/prometheus/operator.go
View File

@@ -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))

41
pkg/prometheus/promcfg.go
View File

@@ -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

38
pkg/prometheus/resource_selector.go
View File

@@ -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)
}
}

101
pkg/prometheus/server/operator.go
View File

@@ -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

17
pkg/prometheus/server/rules.go
View File

@@ -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,
)

11
pkg/prometheus/server/statefulset.go
View File

@@ -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")) {

3
pkg/prometheus/statefulset.go
View File

@@ -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

26
pkg/prometheus/store.go
View File

@@ -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
}