Extend linting configuration file

.drone/drone.yml

@@ -16,7 +16,7 @@ trigger:
 
 steps:
   - name: lint
-    image: golangci/golangci-lint:v1.43
+    image: golangci/golangci-lint:v1.44
     commands:
       - apt-get update -y && apt-get install -y libsystemd-dev
       - make lint
@@ -271,6 +271,6 @@ get:
   name: pat
 ---
 kind: signature
-hmac: 3da266cfeead0295f439b0ec44ba62b6b9c53f2774aef54fe58585e4d51d8990
+hmac: 76ba44a90ab332caf4cd3bc11529e7ea674d4706ab8b4928b17b8c7dcda8abea
 
 ...

.golangci.yml

@@ -60,6 +60,7 @@ linters:
     - unused # new from here.
     - interfacer
     - typecheck
+    - depguard
 
 issues:
   # golangci-lint excludes some stuff we want by default (i.e., proper go-style comments).
@@ -72,3 +73,13 @@ issues:
     # and in most cases it's ok. This is copied from the golangci-lint defaults
     # mut modified to include go-kit logging.
     - Error return value of .((os\.)?std(out|err)\..*|.*Close|.*Flush|os\.Remove(All)?|.*print(f|ln)?|os\.(Un)?Setenv|.*\.Log). is not checked
+
+linters-settings:
+  depguard:
+    list-type: denylist
+    include-go-root: true
+    packages-with-error-message:
+      - sync/atomic: "Use go.uber.org/atomic instead of sync/atomic"
+      - github.com/pkg/errors: "Use errors instead of github.com/pkg/errors"
+      - github.com/go-kit/kit/log: "Use github.com/go-kit/log instead of github.com/go-kit/kit/log"
+      - golang.org/x/sync/errgroup: "Use github.com/oklog/run instead of golang.org/x/sync/errgroup"

pkg/config/config.go

@@ -20,7 +20,6 @@ import (
 	"github.com/grafana/agent/pkg/util"
 	"github.com/grafana/dskit/kv/consul"
 	"github.com/grafana/dskit/kv/etcd"
-	"github.com/pkg/errors"
 	"github.com/prometheus/common/config"
 	"github.com/prometheus/common/version"
 	"github.com/stretchr/testify/require"
@@ -219,7 +218,7 @@ func (c *Config) RegisterFlags(f *flag.FlagSet) {
 func LoadFile(filename string, expandEnvVars bool, c *Config) error {
 	buf, err := ioutil.ReadFile(filename)
 	if err != nil {
-		return errors.Wrap(err, "error reading config file")
+		return fmt.Errorf("error reading config file: %w", err)
 	}
 	return LoadBytes(buf, expandEnvVars, c)
 }

pkg/integrations/v2/autoscrape/autoscrape_test.go

@@ -3,7 +3,6 @@ package autoscrape
 import (
 	"context"
 	"net/http/httptest"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -18,6 +17,7 @@ import (
 	"github.com/prometheus/prometheus/storage"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/atomic"
 )
 
 // TestAutoscrape is a basic end-to-end test of the autoscraper.
@@ -68,15 +68,15 @@ func TestAutoscrape(t *testing.T) {
 	require.NoError(t, wt.Wait(5*time.Second), "timed out waiting for scrape")
 }
 
-var globalRef uint64
+var globalRef atomic.Uint64
 var noOpAppender = mockAppender{
 	AppendFunc: func(ref uint64, l labels.Labels, t int64, v float64) (uint64, error) {
-		return atomic.AddUint64(&globalRef, 1), nil
+		return globalRef.Inc(), nil
 	},
 	CommitFunc:   func() error { return nil },
 	RollbackFunc: func() error { return nil },
 	AppendExemplarFunc: func(ref uint64, l labels.Labels, e exemplar.Exemplar) (uint64, error) {
-		return atomic.AddUint64(&globalRef, 1), nil
+		return globalRef.Inc(), nil
 	},
 }
 

pkg/metrics/wal/wal.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/go-kit/log"
 	"github.com/go-kit/log/level"
-	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/prometheus/pkg/exemplar"
 	"github.com/prometheus/prometheus/pkg/labels"
@@ -164,7 +163,7 @@ func NewStorage(logger log.Logger, registerer prometheus.Registerer, path string
 	if err := storage.replayWAL(); err != nil {
 		level.Warn(storage.logger).Log("msg", "encountered WAL read error, attempting repair", "err", err)
 		if err := w.Repair(err); err != nil {
-			return nil, errors.Wrap(err, "repair corrupted WAL")
+			return nil, fmt.Errorf("repair corrupted WAL: %w", err)
 		}
 	}
 
@@ -182,13 +181,13 @@ func (w *Storage) replayWAL() error {
 	level.Info(w.logger).Log("msg", "replaying WAL, this may take a while", "dir", w.wal.Dir())
 	dir, startFrom, err := wal.LastCheckpoint(w.wal.Dir())
 	if err != nil && err != record.ErrNotFound {
-		return errors.Wrap(err, "find last checkpoint")
+		return fmt.Errorf("find last checkpoint: %w", err)
 	}
 
 	if err == nil {
 		sr, err := wal.NewSegmentsReader(dir)
 		if err != nil {
-			return errors.Wrap(err, "open checkpoint")
+			return fmt.Errorf("open checkpoint: %w", err)
 		}
 		defer func() {
 			if err := sr.Close(); err != nil {
@@ -199,7 +198,7 @@ func (w *Storage) replayWAL() error {
 		// A corrupted checkpoint is a hard error for now and requires user
 		// intervention. There's likely little data that can be recovered anyway.
 		if err := w.loadWAL(wal.NewReader(sr)); err != nil {
-			return errors.Wrap(err, "backfill checkpoint")
+			return fmt.Errorf("backfill checkpoint: %w", err)
 		}
 		startFrom++
 		level.Info(w.logger).Log("msg", "WAL checkpoint loaded")
@@ -208,14 +207,14 @@ func (w *Storage) replayWAL() error {
 	// Find the last segment.
 	_, last, err := wal.Segments(w.wal.Dir())
 	if err != nil {
-		return errors.Wrap(err, "finding WAL segments")
+		return fmt.Errorf("finding WAL segments: %w", err)
 	}
 
 	// Backfill segments from the most recent checkpoint onwards.
 	for i := startFrom; i <= last; i++ {
 		s, err := wal.OpenReadSegment(wal.SegmentName(w.wal.Dir(), i))
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("open WAL segment: %d", i))
+			return fmt.Errorf("open WAL segment %d: %w", i, err)
 		}
 
 		sr := wal.NewSegmentBufReader(s)
@@ -262,7 +261,7 @@ func (w *Storage) loadWAL(r *wal.Reader) (err error) {
 				series, err = dec.Series(rec, series)
 				if err != nil {
 					errCh <- &wal.CorruptionErr{
-						Err:     errors.Wrap(err, "decode series"),
+						Err:     fmt.Errorf("decode series: %w", err),
 						Segment: r.Segment(),
 						Offset:  r.Offset(),
 					}
@@ -274,7 +273,7 @@ func (w *Storage) loadWAL(r *wal.Reader) (err error) {
 				samples, err = dec.Samples(rec, samples)
 				if err != nil {
 					errCh <- &wal.CorruptionErr{
-						Err:     errors.Wrap(err, "decode samples"),
+						Err:     fmt.Errorf("decode samples: %w", err),
 						Segment: r.Segment(),
 						Offset:  r.Offset(),
 					}
@@ -287,7 +286,7 @@ func (w *Storage) loadWAL(r *wal.Reader) (err error) {
 				continue
 			default:
 				errCh <- &wal.CorruptionErr{
-					Err:     errors.Errorf("invalid record type %v", dec.Type(rec)),
+					Err:     fmt.Errorf("invalid record type %v", dec.Type(rec)),
 					Segment: r.Segment(),
 					Offset:  r.Offset(),
 				}
@@ -353,7 +352,7 @@ func (w *Storage) loadWAL(r *wal.Reader) (err error) {
 	}
 
 	if r.Err() != nil {
-		return errors.Wrap(r.Err(), "read records")
+		return fmt.Errorf("read records: %w", r.Err())
 	}
 
 	return nil
@@ -393,14 +392,14 @@ func (w *Storage) Truncate(mint int64) error {
 
 	first, last, err := wal.Segments(w.wal.Dir())
 	if err != nil {
-		return errors.Wrap(err, "get segment range")
+		return fmt.Errorf("get segment range: %w", err)
 	}
 
 	// Start a new segment, so low ingestion volume instance don't have more WAL
 	// than needed.
 	err = w.wal.NextSegment()
 	if err != nil {
-		return errors.Wrap(err, "next segment")
+		return fmt.Errorf("next segment: %w", err)
 	}
 
 	last-- // Never consider last segment for checkpoint.
@@ -426,7 +425,7 @@ func (w *Storage) Truncate(mint int64) error {
 		return ok
 	}
 	if _, err = wal.Checkpoint(w.logger, w.wal, first, last, keep, mint); err != nil {
-		return errors.Wrap(err, "create checkpoint")
+		return fmt.Errorf("create checkpoint: %w", err)
 	}
 	if err := w.wal.Truncate(last + 1); err != nil {
 		// If truncating fails, we'll just try again at the next checkpoint.
@@ -573,11 +572,11 @@ func (a *appender) Append(ref uint64, l labels.Labels, t int64, v float64) (uint
 		// equivalent validation code in the TSDB's headAppender.
 		l = l.WithoutEmpty()
 		if len(l) == 0 {
-			return 0, errors.Wrap(tsdb.ErrInvalidSample, "empty labelset")
+			return 0, fmt.Errorf("empty labelset: %w", tsdb.ErrInvalidSample)
 		}
 
 		if lbl, dup := l.HasDuplicateLabelNames(); dup {
-			return 0, errors.Wrap(tsdb.ErrInvalidSample, fmt.Sprintf(`label name "%s" is not unique`, lbl))
+			return 0, fmt.Errorf("label name %q is not unique: %w", lbl, tsdb.ErrInvalidSample)
 		}
 
 		var created bool
@@ -633,7 +632,7 @@ func (a *appender) AppendExemplar(ref uint64, _ labels.Labels, e exemplar.Exempl
 	e.Labels = e.Labels.WithoutEmpty()
 
 	if lbl, dup := e.Labels.HasDuplicateLabelNames(); dup {
-		return 0, errors.Wrap(tsdb.ErrInvalidExemplar, fmt.Sprintf(`label name "%s" is not unique`, lbl))
+		return 0, fmt.Errorf("label name %q is not unique: %w", lbl, tsdb.ErrInvalidExemplar)
 	}
 
 	// Exemplar label length does not include chars involved in text rendering such as quotes

pkg/operator/clientutil/merge.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/pkg/errors"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/strategicpatch"
 )
@@ -28,21 +27,21 @@ func MergePatchContainers(base, patches []v1.Container) ([]v1.Container, error)
 			// Get the json for the container and the patch
 			containerBytes, err := json.Marshal(container)
 			if err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("failed to marshal json for container %s", container.Name))
+				return nil, fmt.Errorf("failed to marshal json for container %s: %w", container.Name, err)
 			}
 			patchBytes, err := json.Marshal(patchContainer)
 			if err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("failed to marshal json for patch container %s", container.Name))
+				return nil, fmt.Errorf("failed to marshal json for patch container %s: %w", container.Name, err)
 			}
 
 			// Calculate the patch result
 			jsonResult, err := strategicpatch.StrategicMergePatch(containerBytes, patchBytes, v1.Container{})
 			if err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("failed to generate merge patch for %s", container.Name))
+				return nil, fmt.Errorf("failed to generate merge patch for %s: %w", container.Name, err)
 			}
 			var patchResult v1.Container
 			if err := json.Unmarshal(jsonResult, &patchResult); err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("failed to unmarshal merged container %s", container.Name))
+				return nil, fmt.Errorf("failed to unmarshal merged container %s: %w", container.Name, err)
 			}
 
 			// Add the patch result and remove the corresponding key from the to do list