diff --git a/dev-tools/mage/common.go b/dev-tools/mage/common.go
index 0647a13a59a..1c1ca25d95b 100644
--- a/dev-tools/mage/common.go
+++ b/dev-tools/mage/common.go
@@ -29,6 +29,7 @@ import (
 	"debug/elf"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -50,7 +51,6 @@ import (
 	"github.com/magefile/mage/mg"
 	"github.com/magefile/mage/sh"
 	"github.com/magefile/mage/target"
-	"github.com/pkg/errors"
 )
 
 // Expand expands the given Go text/template string.
@@ -91,17 +91,17 @@ func expandTemplate(name, tmpl string, funcs template.FuncMap, args ...map[strin
 	t, err := t.Parse(tmpl)
 	if err != nil {
 		if name == "inline" {
-			return "", errors.Wrapf(err, "failed to parse template '%v'", tmpl)
+			return "", fmt.Errorf("failed to parse template '%v': %w", tmpl, err)
 		}
-		return "", errors.Wrap(err, "failed to parse template")
+		return "", fmt.Errorf("failed to parse template: %w", err)
 	}
 
 	buf := new(bytes.Buffer)
 	if err := t.Execute(buf, joinMaps(args...)); err != nil {
 		if name == "inline" {
-			return "", errors.Wrapf(err, "failed to expand template '%v'", tmpl)
+			return "", fmt.Errorf("failed to expand template '%v': %w", tmpl, err)
 		}
-		return "", errors.Wrap(err, "failed to expand template")
+		return "", fmt.Errorf("failed to expand template: %w", err)
 	}
 
 	return buf.String(), nil
@@ -127,7 +127,7 @@ func joinMaps(args ...map[string]interface{}) map[string]interface{} {
 func expandFile(src, dst string, args ...map[string]interface{}) error {
 	tmplData, err := ioutil.ReadFile(src)
 	if err != nil {
-		return errors.Wrapf(err, "failed reading from template %v", src)
+		return fmt.Errorf("failed reading from template %v: %w", src, err)
 	}
 
 	output, err := expandTemplate(src, string(tmplData), FuncMap, args...)
@@ -141,7 +141,7 @@ func expandFile(src, dst string, args ...map[string]interface{}) error {
 	}
 
 	if err = ioutil.WriteFile(createDir(dst), []byte(output), 0644); err != nil {
-		return errors.Wrap(err, "failed to write rendered template")
+		return fmt.Errorf("failed to write rendered template: %w", err)
 	}
 
 	return nil
@@ -151,7 +151,7 @@ func expandFile(src, dst string, args ...map[string]interface{}) error {
 func CWD(elem ...string) string {
 	wd, err := os.Getwd()
 	if err != nil {
-		panic(errors.Wrap(err, "failed to get the CWD"))
+		panic(fmt.Errorf("failed to get the CWD: %w", err))
 	}
 	return filepath.Join(append([]string{wd}, elem...)...)
 }
@@ -188,7 +188,7 @@ func (info *DockerInfo) IsBoot2Docker() bool {
 // HaveDocker returns an error if docker is unavailable.
 func HaveDocker() error {
 	if _, err := GetDockerInfo(); err != nil {
-		return errors.Wrap(err, "docker is not available")
+		return fmt.Errorf("docker is not available: %w", err)
 	}
 	return nil
 }
@@ -274,7 +274,7 @@ func FindReplace(file string, re *regexp.Regexp, repl string) error {
 // MustFindReplace invokes FindReplace and panics if an error occurs.
 func MustFindReplace(file string, re *regexp.Regexp, repl string) {
 	if err := FindReplace(file, re, repl); err != nil {
-		panic(errors.Wrap(err, "failed to find and replace"))
+		panic(fmt.Errorf("failed to find and replace: %w", err))
 	}
 }
 
@@ -285,23 +285,23 @@ func DownloadFile(url, destinationDir string) (string, error) {
 
 	resp, err := http.Get(url)
 	if err != nil {
-		return "", errors.Wrap(err, "http get failed")
+		return "", fmt.Errorf("http get failed: %w", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		return "", errors.Errorf("download failed with http status: %v", resp.StatusCode)
+		return "", fmt.Errorf("download failed with http status: %v", resp.StatusCode)
 	}
 
 	name := filepath.Join(destinationDir, filepath.Base(url))
 	f, err := os.Create(createDir(name))
 	if err != nil {
-		return "", errors.Wrap(err, "failed to create output file")
+		return "", fmt.Errorf("failed to create output file: %w", err)
 	}
 	defer f.Close()
 
 	if _, err = io.Copy(f, resp.Body); err != nil {
-		return "", errors.Wrap(err, "failed to write file")
+		return "", fmt.Errorf("failed to write file: %w", err)
 	}
 
 	return name, f.Close()
@@ -316,7 +316,7 @@ func Extract(sourceFile, destinationDir string) error {
 	case ext == ".zip":
 		return unzip(sourceFile, destinationDir)
 	default:
-		return errors.Errorf("failed to extract %v, unhandled file extension", sourceFile)
+		return fmt.Errorf("failed to extract %v, unhandled file extension", sourceFile)
 	}
 }
 
@@ -340,7 +340,7 @@ func unzip(sourceFile, destinationDir string) error {
 
 		path := filepath.Join(destinationDir, f.Name)
 		if !strings.HasPrefix(path, destinationDir) {
-			return errors.Errorf("illegal file path in zip: %v", f.Name)
+			return fmt.Errorf("illegal file path in zip: %v", f.Name)
 		}
 
 		if f.FileInfo().IsDir() {
@@ -485,7 +485,7 @@ func untar(sourceFile, destinationDir string) error {
 
 		path := filepath.Join(destinationDir, header.Name)
 		if !strings.HasPrefix(path, destinationDir) {
-			return errors.Errorf("illegal file path in tar: %v", header.Name)
+			return fmt.Errorf("illegal file path in tar: %v", header.Name)
 		}
 
 		switch header.Typeflag {
@@ -511,7 +511,7 @@ func untar(sourceFile, destinationDir string) error {
 				return err
 			}
 		default:
-			return errors.Errorf("unable to untar type=%c in file=%s", header.Typeflag, path)
+			return fmt.Errorf("unable to untar type=%c in file=%s", header.Typeflag, path)
 		}
 	}
 
@@ -613,7 +613,7 @@ func ParallelCtx(ctx context.Context, fns ...interface{}) {
 
 	wg.Wait()
 	if len(errs) > 0 {
-		panic(errors.Errorf(strings.Join(errs, "\n")))
+		panic(fmt.Errorf(strings.Join(errs, "\n")))
 	}
 }
 
@@ -652,7 +652,7 @@ func FindFiles(globs ...string) ([]string, error) {
 	for _, glob := range globs {
 		files, err := filepath.Glob(glob)
 		if err != nil {
-			return nil, errors.Wrapf(err, "failed on glob %v", glob)
+			return nil, fmt.Errorf("failed on glob %v: %w", glob, err)
 		}
 		configFiles = append(configFiles, files...)
 	}
@@ -691,7 +691,7 @@ func FindFilesRecursive(match func(path string, info os.FileInfo) bool) ([]strin
 func FileConcat(out string, perm os.FileMode, files ...string) error {
 	f, err := os.OpenFile(createDir(out), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, perm)
 	if err != nil {
-		return errors.Wrap(err, "failed to create file")
+		return fmt.Errorf("failed to create file: %w", err)
 	}
 	defer f.Close()
 
@@ -735,20 +735,20 @@ func MustFileConcat(out string, perm os.FileMode, files ...string) {
 func VerifySHA256(file string, hash string) error {
 	f, err := os.Open(file)
 	if err != nil {
-		return errors.Wrap(err, "failed to open file for sha256 verification")
+		return fmt.Errorf("failed to open file for sha256 verification: %w", err)
 	}
 	defer f.Close()
 
 	sum := sha256.New()
 	if _, err := io.Copy(sum, f); err != nil {
-		return errors.Wrap(err, "failed reading from input file")
+		return fmt.Errorf("failed reading from input file: %w", err)
 	}
 
 	computedHash := hex.EncodeToString(sum.Sum(nil))
 	expectedHash := strings.TrimSpace(hash)
 
 	if computedHash != expectedHash {
-		return errors.Errorf("SHA256 verification of %v failed. Expected=%v, "+
+		return fmt.Errorf("SHA256 verification of %v failed. Expected=%v, "+
 			"but computed=%v", f.Name(), expectedHash, computedHash)
 	}
 	log.Println("SHA256 OK:", f.Name())
@@ -761,13 +761,13 @@ func VerifySHA256(file string, hash string) error {
 func CreateSHA512File(file string) error {
 	f, err := os.Open(file)
 	if err != nil {
-		return errors.Wrap(err, "failed to open file for sha512 summing")
+		return fmt.Errorf("failed to open file for sha512 summing: %w", err)
 	}
 	defer f.Close()
 
 	sum := sha512.New()
 	if _, err := io.Copy(sum, f); err != nil {
-		return errors.Wrap(err, "failed reading from input file")
+		return fmt.Errorf("failed reading from input file: %w", err)
 	}
 
 	computedHash := hex.EncodeToString(sum.Sum(nil))
@@ -856,7 +856,7 @@ func XPackBeatDir(path ...string) string {
 func LibbeatDir(path ...string) string {
 	esBeatsDir, err := ElasticBeatsDir()
 	if err != nil {
-		panic(errors.Wrap(err, "failed determine libbeat dir location"))
+		panic(fmt.Errorf("failed determine libbeat dir location: %w", err))
 	}
 
 	return filepath.Join(append([]string{esBeatsDir, "libbeat"}, path...)...)
@@ -873,7 +873,7 @@ func CreateDir(file string) string {
 	// Create the output directory.
 	if dir := filepath.Dir(file); dir != "." {
 		if err := os.MkdirAll(dir, 0755); err != nil {
-			panic(errors.Wrapf(err, "failed to create parent dir for %v", file))
+			panic(fmt.Errorf("failed to create parent dir for %v: %w", file, err))
 		}
 	}
 	return file
@@ -895,7 +895,7 @@ func ParseVersion(version string) (major, minor, patch int, err error) {
 	names := parseVersionRegex.SubexpNames()
 	matches := parseVersionRegex.FindStringSubmatch(version)
 	if len(matches) == 0 {
-		err = errors.Errorf("failed to parse version '%v'", version)
+		err = fmt.Errorf("failed to parse version '%v'", version)
 		return
 	}
 
diff --git a/dev-tools/mage/config.go b/dev-tools/mage/config.go
index adfa4c74541..822e7f0f163 100644
--- a/dev-tools/mage/config.go
+++ b/dev-tools/mage/config.go
@@ -19,6 +19,7 @@ package mage
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -30,7 +31,6 @@ import (
 
 	"github.com/magefile/mage/mg"
 
-	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 )
 
@@ -98,7 +98,7 @@ func Config(types ConfigFileType, args ConfigFileParams, targetDir string) error
 	if types.IsShort() {
 		file := filepath.Join(targetDir, BeatName+".yml")
 		if err := makeConfigTemplate(file, 0600, args, ShortConfigType); err != nil {
-			return errors.Wrap(err, "failed making short config")
+			return fmt.Errorf("failed making short config: %w", err)
 		}
 	}
 
@@ -106,7 +106,7 @@ func Config(types ConfigFileType, args ConfigFileParams, targetDir string) error
 	if types.IsReference() {
 		file := filepath.Join(targetDir, BeatName+".reference.yml")
 		if err := makeConfigTemplate(file, 0644, args, ReferenceConfigType); err != nil {
-			return errors.Wrap(err, "failed making reference config")
+			return fmt.Errorf("failed making reference config: %w", err)
 		}
 	}
 
@@ -114,7 +114,7 @@ func Config(types ConfigFileType, args ConfigFileParams, targetDir string) error
 	if types.IsDocker() {
 		file := filepath.Join(targetDir, BeatName+".docker.yml")
 		if err := makeConfigTemplate(file, 0600, args, DockerConfigType); err != nil {
-			return errors.Wrap(err, "failed making docker config")
+			return fmt.Errorf("failed making docker config: %w", err)
 		}
 	}
 
@@ -136,7 +136,7 @@ func makeConfigTemplate(destination string, mode os.FileMode, confParams ConfigF
 		confFile = confParams.Docker
 		tmplParams = map[string]interface{}{"Docker": true}
 	default:
-		panic(errors.Errorf("Invalid config file type: %v", typ))
+		panic(fmt.Errorf("Invalid config file type: %v", typ))
 	}
 
 	// Build the dependencies.
@@ -192,18 +192,18 @@ func makeConfigTemplate(destination string, mode os.FileMode, confParams ConfigF
 	var err error
 	for _, templateGlob := range confParams.Templates {
 		if tmpl, err = tmpl.ParseGlob(templateGlob); err != nil {
-			return errors.Wrapf(err, "failed to parse config templates in %q", templateGlob)
+			return fmt.Errorf("failed to parse config templates in %q: %w", templateGlob, err)
 		}
 	}
 
 	data, err := ioutil.ReadFile(confFile.Template)
 	if err != nil {
-		return errors.Wrapf(err, "failed to read config template %q", confFile.Template)
+		return fmt.Errorf("failed to read config template %q: %w", confFile.Template, err)
 	}
 
 	tmpl, err = tmpl.Parse(string(data))
 	if err != nil {
-		return errors.Wrap(err, "failed to parse template")
+		return fmt.Errorf("failed to parse template: %w", err)
 	}
 
 	out, err := os.OpenFile(CreateDir(destination), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, mode)
@@ -213,7 +213,7 @@ func makeConfigTemplate(destination string, mode os.FileMode, confParams ConfigF
 	defer out.Close()
 
 	if err = tmpl.Execute(out, EnvMap(params)); err != nil {
-		return errors.Wrapf(err, "failed building %v", destination)
+		return fmt.Errorf("failed building %v: %w", destination, err)
 	}
 
 	return nil
diff --git a/dev-tools/mage/copy.go b/dev-tools/mage/copy.go
index c4774539871..fc9aa854823 100644
--- a/dev-tools/mage/copy.go
+++ b/dev-tools/mage/copy.go
@@ -18,13 +18,12 @@
 package mage
 
 import (
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
-
-	"github.com/pkg/errors"
 )
 
 // Copy copies a file or a directory (recursively) and preserves the permissions.
@@ -38,7 +37,7 @@ func CopyFile(src, dest string) error {
 	copy := &CopyTask{Source: src, Dest: dest}
 	info, err := os.Stat(src)
 	if err != nil {
-		return errors.Wrapf(err, "copy failed: cannot stat source file %v", src)
+		return fmt.Errorf("copy failed: cannot stat source file %v: %w", src, err)
 	}
 	return copy.fileCopy(src, dest, info)
 }
@@ -56,22 +55,27 @@ type CopyTask struct {
 // Execute executes the copy and returns an error of there is a failure.
 func (t *CopyTask) Execute() error {
 	if err := t.init(); err != nil {
-		return errors.Wrap(err, "copy failed")
+		return fmt.Errorf("copy failed: %w", err)
 	}
 
 	info, err := os.Stat(t.Source)
 	if err != nil {
-		return errors.Wrapf(err, "copy failed: cannot stat source file %v", t.Source)
+		return fmt.Errorf("copy failed: cannot stat source file %v: %w", t.Source, err)
 	}
 
-	return errors.Wrap(t.recursiveCopy(t.Source, t.Dest, info), "copy failed")
+	err = t.recursiveCopy(t.Source, t.Dest, info)
+	if err != nil {
+		return fmt.Errorf("copy failed: %w", err)
+	}
+
+	return nil
 }
 
 func (t *CopyTask) init() error {
 	for _, excl := range t.Exclude {
 		re, err := regexp.Compile(excl)
 		if err != nil {
-			return errors.Wrapf(err, "bad exclude pattern %v", excl)
+			return fmt.Errorf("bad exclude pattern %v: %w", excl, err)
 		}
 		t.excludes = append(t.excludes, re)
 	}
@@ -106,7 +110,7 @@ func (t *CopyTask) fileCopy(src, dest string, info os.FileInfo) error {
 	defer srcFile.Close()
 
 	if !info.Mode().IsRegular() {
-		return errors.Errorf("failed to copy source file because it is not a " +
+		return fmt.Errorf("failed to copy source file because it is not a " +
 			"regular file")
 	}
 
@@ -137,19 +141,19 @@ func (t *CopyTask) dirCopy(src, dest string, info os.FileInfo) error {
 		mode = info.Mode()
 	}
 	if err := os.MkdirAll(dest, mode&os.ModePerm); err != nil {
-		return errors.Wrap(err, "failed creating dirs")
+		return fmt.Errorf("failed creating dirs: %w", err)
 	}
 
 	contents, err := ioutil.ReadDir(src)
 	if err != nil {
-		return errors.Wrapf(err, "failed to read dir %v", src)
+		return fmt.Errorf("failed to read dir %v: %w", src, err)
 	}
 
 	for _, info := range contents {
 		srcFile := filepath.Join(src, info.Name())
 		destFile := filepath.Join(dest, info.Name())
 		if err = t.recursiveCopy(srcFile, destFile, info); err != nil {
-			return errors.Wrapf(err, "failed to copy %v to %v", srcFile, destFile)
+			return fmt.Errorf("failed to copy %v to %v: %w", srcFile, destFile, err)
 		}
 	}
 
diff --git a/dev-tools/mage/dockerbuilder.go b/dev-tools/mage/dockerbuilder.go
index b9c48c2c35f..2066670dc80 100644
--- a/dev-tools/mage/dockerbuilder.go
+++ b/dev-tools/mage/dockerbuilder.go
@@ -20,6 +20,7 @@ package mage
 import (
 	"bytes"
 	"compress/gzip"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -29,7 +30,6 @@ import (
 	"time"
 
 	"github.com/magefile/mage/sh"
-	"github.com/pkg/errors"
 )
 
 type dockerBuilder struct {
@@ -59,7 +59,7 @@ func newDockerBuilder(spec PackageSpec) (*dockerBuilder, error) {
 
 func (b *dockerBuilder) Build() error {
 	if err := os.RemoveAll(b.buildDir); err != nil {
-		return errors.Wrapf(err, "failed to clean existing build directory %s", b.buildDir)
+		return fmt.Errorf("failed to clean existing build directory %s: %w", b.buildDir, err)
 	}
 
 	if err := b.copyFiles(); err != nil {
@@ -67,7 +67,7 @@ func (b *dockerBuilder) Build() error {
 	}
 
 	if err := b.prepareBuild(); err != nil {
-		return errors.Wrap(err, "failed to prepare build")
+		return fmt.Errorf("failed to prepare build: %w", err)
 	}
 
 	tag, err := b.dockerBuild()
@@ -80,11 +80,11 @@ func (b *dockerBuilder) Build() error {
 		tries -= 1
 	}
 	if err != nil {
-		return errors.Wrap(err, "failed to build docker")
+		return fmt.Errorf("failed to build docker: %w", err)
 	}
 
 	if err := b.dockerSave(tag); err != nil {
-		return errors.Wrap(err, "failed to save docker as artifact")
+		return fmt.Errorf("failed to save docker as artifact: %w", err)
 	}
 
 	return nil
@@ -114,7 +114,7 @@ func (b *dockerBuilder) copyFiles() error {
 			if f.SkipOnMissing && errors.Is(err, os.ErrNotExist) {
 				continue
 			}
-			return errors.Wrapf(err, "failed to copy from %s to %s", f.Source, target)
+			return fmt.Errorf("failed to copy from %s to %s: %w", f.Source, target, err)
 		}
 	}
 	return nil
@@ -141,7 +141,7 @@ func (b *dockerBuilder) prepareBuild() error {
 
 			err = b.ExpandFile(path, target, data)
 			if err != nil {
-				return errors.Wrapf(err, "expanding template '%s' to '%s'", path, target)
+				return fmt.Errorf("expanding template '%s' to '%s': %w", path, target, err)
 			}
 		}
 		return nil
@@ -182,7 +182,7 @@ func (b *dockerBuilder) expandDockerfile(templatesDir string, data map[string]in
 		path := filepath.Join(templatesDir, file.source)
 		err := b.ExpandFile(path, target, data)
 		if err != nil {
-			return errors.Wrapf(err, "expanding template '%s' to '%s'", path, target)
+			return fmt.Errorf("expanding template '%s' to '%s': %w", path, target, err)
 		}
 	}
 
@@ -251,9 +251,13 @@ func (b *dockerBuilder) dockerSave(tag string) error {
 
 	if err = cmd.Wait(); err != nil {
 		if errmsg := strings.TrimSpace(stderr.String()); errmsg != "" {
-			err = errors.Wrap(errors.New(errmsg), err.Error())
+			err = fmt.Errorf(err.Error()+": %w", errors.New(errmsg))
 		}
 		return err
 	}
-	return errors.Wrap(CreateSHA512File(outputFile), "failed to create .sha512 file")
+
+	if err = CreateSHA512File(outputFile); err != nil {
+		return fmt.Errorf("failed to create .sha512 file: %w", err)
+	}
+	return nil
 }
diff --git a/dev-tools/mage/fields.go b/dev-tools/mage/fields.go
index aff1a3be28c..b90e4e22fa5 100644
--- a/dev-tools/mage/fields.go
+++ b/dev-tools/mage/fields.go
@@ -18,10 +18,9 @@
 package mage
 
 import (
+	"fmt"
 	"path/filepath"
 
-	"github.com/pkg/errors"
-
 	"github.com/magefile/mage/sh"
 )
 
@@ -229,6 +228,6 @@ func toLibbeatLicenseName(name string) string {
 	case "Elastic License":
 		return "Elastic"
 	default:
-		panic(errors.Errorf("invalid license name '%v'", name))
+		panic(fmt.Errorf("invalid license name '%v'", name))
 	}
 }
diff --git a/dev-tools/mage/gomod.go b/dev-tools/mage/gomod.go
index 11ad159b841..de67f94797a 100644
--- a/dev-tools/mage/gomod.go
+++ b/dev-tools/mage/gomod.go
@@ -18,11 +18,10 @@
 package mage
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/dev-tools/mage/gotool"
 )
 
@@ -38,7 +37,7 @@ func CopyFilesToVendor(vendorFolder string, modulesToCopy []CopyModule) error {
 	for _, p := range modulesToCopy {
 		path, err := gotool.ListModuleCacheDir(p.Name)
 		if err != nil {
-			return errors.Wrapf(err, "error while looking up cached dir of module: %s", p.Name)
+			return fmt.Errorf("error while looking up cached dir of module: %s: %w", p.Name, err)
 		}
 
 		for _, f := range p.FilesToCopy {
@@ -47,7 +46,7 @@ func CopyFilesToVendor(vendorFolder string, modulesToCopy []CopyModule) error {
 			copyTask := &CopyTask{Source: from, Dest: to, Mode: 0600, DirMode: os.ModeDir | 0750}
 			err = copyTask.Execute()
 			if err != nil {
-				return errors.Wrapf(err, "error while copying file from %s to %s", from, to)
+				return fmt.Errorf("error while copying file from %s to %s: %w", from, to, err)
 			}
 		}
 	}
diff --git a/dev-tools/mage/keychain.go b/dev-tools/mage/keychain.go
index c66bec16d35..4435604ea57 100644
--- a/dev-tools/mage/keychain.go
+++ b/dev-tools/mage/keychain.go
@@ -18,6 +18,7 @@
 package mage
 
 import (
+	"fmt"
 	"log"
 	"regexp"
 	"strconv"
@@ -25,7 +26,6 @@ import (
 	"sync"
 
 	"github.com/magefile/mage/sh"
-	"github.com/pkg/errors"
 )
 
 var _appleKeychain = &appleKeychain{}
@@ -138,19 +138,19 @@ func getAppleSigningInfo() (*AppleSigningInfo, error) {
 	}
 
 	if len(install) > 1 {
-		return nil, errors.Errorf("found multiple installer signing identities "+
+		return nil, fmt.Errorf("found multiple installer signing identities "+
 			"that match '%v'. Set a more specific APPLE_SIGNING_IDENTITY_INSTALLER "+
 			"value that will select one of %+v", identityInstaller, install)
 	}
 
 	if len(app) > 1 {
-		return nil, errors.Errorf("found multiple installer signing identities "+
+		return nil, fmt.Errorf("found multiple installer signing identities "+
 			"that match '%v'. Set a more specific APPLE_SIGNING_IDENTITY_APP "+
 			"value that will select one of %+v", identityApp, app)
 	}
 
 	if len(install) == 0 || len(app) == 0 {
-		return nil, errors.Errorf("apple signing was requested with " +
+		return nil, fmt.Errorf("apple signing was requested with " +
 			"APPLE_SIGNING_ENABLED=true, but the required signing identities " +
 			"for app and installer were not found")
 	}
diff --git a/dev-tools/mage/kibana.go b/dev-tools/mage/kibana.go
index a556e5b5429..47e67a24a50 100644
--- a/dev-tools/mage/kibana.go
+++ b/dev-tools/mage/kibana.go
@@ -18,11 +18,11 @@
 package mage
 
 import (
+	"errors"
+	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
-
-	"github.com/pkg/errors"
 )
 
 const kibanaBuildDir = "build/kibana"
@@ -81,7 +81,7 @@ func PackageKibanaDashboardsFromBuildDir() {
 			case Deb, RPM:
 				pkgArgs.Spec.ReplaceFile("/usr/share/{{.BeatName}}/kibana", kibanaDashboards)
 			default:
-				panic(errors.Errorf("unhandled package type: %v", pkgType))
+				panic(fmt.Errorf("unhandled package type: %v", pkgType))
 			}
 			break
 		}
diff --git a/dev-tools/mage/kubernetes/kuberemote.go b/dev-tools/mage/kubernetes/kuberemote.go
index 3bb540a42da..8e9d9897d44 100644
--- a/dev-tools/mage/kubernetes/kuberemote.go
+++ b/dev-tools/mage/kubernetes/kuberemote.go
@@ -35,7 +35,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
 	"golang.org/x/crypto/ssh"
 
 	apiv1 "k8s.io/api/core/v1"
@@ -97,7 +96,7 @@ func NewKubeRemote(kubeconfig string, namespace string, name string, workDir str
 // Run runs the command remotely on the kubernetes cluster.
 func (r *KubeRemote) Run(env map[string]string, stdout io.Writer, stderr io.Writer, args ...string) error {
 	if err := r.syncSSHKey(); err != nil {
-		return errors.Wrap(err, "failed to sync SSH secret")
+		return fmt.Errorf("failed to sync SSH secret: %w", err)
 	}
 	defer r.deleteSSHKey()
 	if err := r.syncServiceAccount(); err != nil {
@@ -106,21 +105,21 @@ func (r *KubeRemote) Run(env map[string]string, stdout io.Writer, stderr io.Writ
 	defer r.deleteServiceAccount()
 	_, err := r.createPod(env, args...)
 	if err != nil {
-		return errors.Wrap(err, "failed to create execute pod")
+		return fmt.Errorf("failed to create execute pod: %w", err)
 	}
 	defer r.deletePod()
 
 	// wait for SSH to be up inside the init container.
 	_, err = r.waitForPod(5*time.Minute, podInitReady)
 	if err != nil {
-		return errors.Wrap(err, "execute pod init container never started")
+		return fmt.Errorf("execute pod init container never started: %w", err)
 	}
 	time.Sleep(1 * time.Second) // SSH inside of container can take a moment
 
 	// forward the SSH port so rsync can be ran.
 	randomPort, err := getFreePort()
 	if err != nil {
-		return errors.Wrap(err, "failed to find a free port")
+		return fmt.Errorf("failed to find a free port: %w", err)
 	}
 	stopChannel := make(chan struct{}, 1)
 	readyChannel := make(chan struct{}, 1)
@@ -140,19 +139,19 @@ func (r *KubeRemote) Run(env map[string]string, stdout io.Writer, stderr io.Writ
 	// wait for exec container to be running
 	_, err = r.waitForPod(5*time.Minute, containerRunning("exec"))
 	if err != nil {
-		return errors.Wrap(err, "execute pod container never started")
+		return fmt.Errorf("execute pod container never started: %w", err)
 	}
 
 	// stream the logs of the container
 	err = r.streamLogs("exec", stdout)
 	if err != nil {
-		return errors.Wrap(err, "failed to stream the logs")
+		return fmt.Errorf("failed to stream the logs: %w", err)
 	}
 
 	// wait for exec container to be completely done
 	pod, err := r.waitForPod(30*time.Second, podDone)
 	if err != nil {
-		return errors.Wrap(err, "execute pod didn't terminate after 30 seconds of log stream")
+		return fmt.Errorf("execute pod didn't terminate after 30 seconds of log stream: %w", err)
 	}
 
 	// return error on failure
@@ -199,18 +198,18 @@ func (r *KubeRemote) syncServiceAccount() error {
 		createServiceAccountManifest(r.svcAccName),
 		metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "failed to create service account")
+		return fmt.Errorf("failed to create service account: %w", err)
 	}
 	_, err = r.cs.RbacV1().ClusterRoles().Create(ctx, createClusterRoleManifest(r.name), metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "failed to create cluster role")
+		return fmt.Errorf("failed to create cluster role: %w", err)
 	}
 	_, err = r.cs.RbacV1().ClusterRoleBindings().Create(
 		ctx,
 		createClusterRoleBindingManifest(r.name, r.namespace, r.svcAccName),
 		metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "failed to create cluster role binding")
+		return fmt.Errorf("failed to create cluster role binding: %w", err)
 	}
 	return nil
 }
diff --git a/dev-tools/mage/kubernetes/kubernetes.go b/dev-tools/mage/kubernetes/kubernetes.go
index 9b25f316b2c..e93632d7b65 100644
--- a/dev-tools/mage/kubernetes/kubernetes.go
+++ b/dev-tools/mage/kubernetes/kubernetes.go
@@ -29,7 +29,6 @@ import (
 	"time"
 
 	"github.com/magefile/mage/mg"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/dev-tools/mage"
 )
@@ -106,14 +105,14 @@ func (d *KubernetesIntegrationTester) Test(dir string, mageTarget string, env ma
 	// Apply the manifest from the dir. This is the requirements for the tests that will
 	// run inside the cluster.
 	if err := KubectlApply(env, stdOut, stdErr, manifestPath); err != nil {
-		return errors.Wrapf(err, "failed to apply manifest %s", manifestPath)
+		return fmt.Errorf("failed to apply manifest %s: %w", manifestPath, err)
 	}
 	defer func() {
 		if mg.Verbose() {
 			fmt.Println(">> Deleting module manifest from cluster...")
 		}
 		if err := KubectlDelete(env, stdOut, stdErr, manifestPath); err != nil {
-			log.Printf("%s", errors.Wrapf(err, "failed to apply manifest %s", manifestPath))
+			log.Printf("%s", fmt.Errorf("failed to apply manifest %s: %w", manifestPath, err))
 		}
 	}()
 
@@ -164,7 +163,7 @@ func waitKubeStateMetricsReadiness(env map[string]string, stdOut, stdErr io.Writ
 			break
 		}
 		if readyAttempts > checkKubeStateMetricsReadyAttempts {
-			return errors.Wrapf(err, "Timeout waiting for kube-state-metrics")
+			return fmt.Errorf("Timeout waiting for kube-state-metrics: %w", err)
 		}
 		time.Sleep(6 * time.Second)
 		readyAttempts += 1
@@ -177,12 +176,12 @@ func waitKubeStateMetricsReadiness(env map[string]string, stdOut, stdErr io.Writ
 func kubernetesClusterName() string {
 	commit, err := mage.CommitHash()
 	if err != nil {
-		panic(errors.Wrap(err, "failed to construct kind cluster name"))
+		panic(fmt.Errorf("failed to construct kind cluster name:  %w", err))
 	}
 
 	version, err := mage.BeatQualifiedVersion()
 	if err != nil {
-		panic(errors.Wrap(err, "failed to construct kind cluster name"))
+		panic(fmt.Errorf("failed to construct kind cluster name:  %w", err))
 	}
 	version = strings.NewReplacer(".", "-").Replace(version)
 
@@ -202,7 +201,7 @@ func kubernetesClusterName() string {
 	// Note that underscores, in particular, are not permitted.
 	matched, err := regexp.MatchString(subDomainPattern, clusterName)
 	if err != nil {
-		panic(errors.Wrap(err, "error while validating kind cluster name"))
+		panic(fmt.Errorf("error while validating kind cluster name: %w", err))
 	}
 	if !matched {
 		panic("constructed invalid kind cluster name")
diff --git a/dev-tools/mage/modules.go b/dev-tools/mage/modules.go
index a65c2c2a121..14b7f7ab118 100644
--- a/dev-tools/mage/modules.go
+++ b/dev-tools/mage/modules.go
@@ -25,7 +25,6 @@ import (
 	"strings"
 
 	"github.com/joeshaw/multierror"
-	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 )
 
@@ -131,11 +130,11 @@ func loadModulesD() (modules map[string][]moduleDefinition, err error) {
 	for _, file := range files {
 		contents, err := ioutil.ReadFile(file)
 		if err != nil {
-			return nil, errors.Wrapf(err, "reading %s", file)
+			return nil, fmt.Errorf("reading %s: %w", file, err)
 		}
 		var cfg []moduleDefinition
 		if err = yaml.Unmarshal(contents, &cfg); err != nil {
-			return nil, errors.Wrapf(err, "parsing %s as YAML", file)
+			return nil, fmt.Errorf("parsing %s as YAML: %w", file, err)
 		}
 		modules[file] = cfg
 	}
diff --git a/dev-tools/mage/pkgspecs.go b/dev-tools/mage/pkgspecs.go
index 7a029238b61..9d0a6b339b4 100644
--- a/dev-tools/mage/pkgspecs.go
+++ b/dev-tools/mage/pkgspecs.go
@@ -19,11 +19,11 @@ package mage
 
 import (
 	"bytes"
+	"fmt"
 	"io/ioutil"
 	"log"
 	"path/filepath"
 
-	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 )
 
@@ -72,12 +72,12 @@ func MustUsePackaging(specName, specFile string) {
 func LoadNamedSpec(name string, files ...string) error {
 	specs, err := LoadSpecs(files...)
 	if err != nil {
-		return errors.Wrap(err, "failed to load spec file")
+		return fmt.Errorf("failed to load spec file: %w", err)
 	}
 
 	packages, found := specs[name]
 	if !found {
-		return errors.Errorf("%v not found in package specs", name)
+		return fmt.Errorf("%v not found in package specs", name)
 	}
 
 	log.Printf("%v package spec loaded from %v", name, files)
@@ -91,7 +91,7 @@ func LoadSpecs(files ...string) (map[string][]OSPackageArgs, error) {
 	for _, file := range files {
 		d, err := ioutil.ReadFile(file)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to read from spec file")
+			return nil, fmt.Errorf("failed to read from spec file: %w", err)
 		}
 		data = append(data, d)
 	}
@@ -102,7 +102,7 @@ func LoadSpecs(files ...string) (map[string][]OSPackageArgs, error) {
 
 	var packages PackageYAML
 	if err := yaml.Unmarshal(bytes.Join(data, []byte{'\n'}), &packages); err != nil {
-		return nil, errors.Wrap(err, "failed to unmarshal spec data")
+		return nil, fmt.Errorf("failed to unmarshal spec data: %w", err)
 	}
 
 	return packages.Specs, nil
diff --git a/dev-tools/mage/pkgtypes.go b/dev-tools/mage/pkgtypes.go
index 7a775850cf3..249612f8feb 100644
--- a/dev-tools/mage/pkgtypes.go
+++ b/dev-tools/mage/pkgtypes.go
@@ -36,7 +36,6 @@ import (
 	"github.com/magefile/mage/mg"
 	"github.com/magefile/mage/sh"
 	"github.com/mitchellh/hashstructure"
-	"github.com/pkg/errors"
 )
 
 const (
@@ -185,19 +184,19 @@ var OSArchNames = map[string]map[PackageType]map[string]string{
 func getOSArchName(platform BuildPlatform, t PackageType) (string, error) {
 	names, found := OSArchNames[platform.GOOS()]
 	if !found {
-		return "", errors.Errorf("arch names for os=%v are not defined",
+		return "", fmt.Errorf("arch names for os=%v are not defined",
 			platform.GOOS())
 	}
 
 	archMap, found := names[t]
 	if !found {
-		return "", errors.Errorf("arch names for %v on os=%v are not defined",
+		return "", fmt.Errorf("arch names for %v on os=%v are not defined",
 			t, platform.GOOS())
 	}
 
 	arch, found := archMap[platform.Arch()]
 	if !found {
-		return "", errors.Errorf("arch name associated with %v for %v on "+
+		return "", fmt.Errorf("arch name associated with %v for %v on "+
 			"os=%v is not defined", platform.Arch(), t, platform.GOOS())
 	}
 
@@ -241,7 +240,7 @@ func (typ *PackageType) UnmarshalText(text []byte) error {
 	case "docker":
 		*typ = Docker
 	default:
-		return errors.Errorf("unknown package type: %v", string(text))
+		return fmt.Errorf("unknown package type: %v", string(text))
 	}
 	return nil
 }
@@ -286,7 +285,7 @@ func (typ PackageType) Build(spec PackageSpec) error {
 	case Docker:
 		return PackageDocker(spec)
 	default:
-		return errors.Errorf("unknown package type: %v", typ)
+		return fmt.Errorf("unknown package type: %v", typ)
 	}
 }
 
@@ -309,7 +308,7 @@ func (s PackageSpec) Clone() PackageSpec {
 func (s PackageSpec) ReplaceFile(target string, file PackageFile) {
 	_, found := s.Files[target]
 	if !found {
-		panic(errors.Errorf("failed to ReplaceFile because target=%v does not exist", target))
+		panic(fmt.Errorf("failed to ReplaceFile because target=%v does not exist", target))
 	}
 
 	s.Files[target] = file
@@ -407,7 +406,7 @@ func (s PackageSpec) Evaluate(args ...map[string]interface{}) PackageSpec {
 		// Execute the dependency if it exists.
 		if f.Dep != nil {
 			if err := f.Dep(s); err != nil {
-				panic(errors.Wrapf(err, "failed executing package file dependency for target=%v", target))
+				panic(fmt.Errorf("failed executing package file dependency for target=%v: %w", target, err))
 			}
 		}
 
@@ -422,20 +421,20 @@ func (s PackageSpec) Evaluate(args ...map[string]interface{}) PackageSpec {
 		case f.Content != "":
 			content, err := s.Expand(f.Content)
 			if err != nil {
-				panic(errors.Wrapf(err, "failed to expand content template for target=%v", target))
+				panic(fmt.Errorf("failed to expand content template for target=%v: %w", target, err))
 			}
 
 			f.Source = filepath.Join(s.packageDir, filepath.Base(f.Target))
 			if err = ioutil.WriteFile(CreateDir(f.Source), []byte(content), 0644); err != nil {
-				panic(errors.Wrapf(err, "failed to write file containing content for target=%v", target))
+				panic(fmt.Errorf("failed to write file containing content for target=%v: %w", target, err))
 			}
 		case f.Template != "":
 			f.Source = filepath.Join(s.packageDir, filepath.Base(f.Template))
 			if err := s.ExpandFile(f.Template, CreateDir(f.Source)); err != nil {
-				panic(errors.Wrapf(err, "failed to expand template file for target=%v", target))
+				panic(fmt.Errorf("failed to expand template file for target=%v: %w", target, err))
 			}
 		default:
-			panic(errors.Errorf("package file with target=%v must have either source, content, or template", target))
+			panic(fmt.Errorf("package file with target=%v must have either source, content, or template", target))
 		}
 
 		evaluatedFiles[f.Target] = f
@@ -459,7 +458,7 @@ func (s PackageSpec) ImageName() (string, error) {
 	if name, _ := s.ExtraVars["image_name"]; name != "" {
 		imageName, err := s.Expand(name)
 		if err != nil {
-			return "", errors.Wrapf(err, "failed to expand image_name")
+			return "", fmt.Errorf("failed to expand image_name: %w", err)
 		}
 		return imageName, nil
 	}
@@ -481,11 +480,11 @@ func copyInstallScript(spec PackageSpec, script string, local *string) error {
 	}
 
 	if err := spec.ExpandFile(script, createDir(*local)); err != nil {
-		return errors.Wrap(err, "failed to copy install script to package dir")
+		return fmt.Errorf("failed to copy install script to package dir: %w", err)
 	}
 
 	if err := os.Chmod(*local, 0755); err != nil {
-		return errors.Wrap(err, "failed to chmod install script")
+		return fmt.Errorf("failed to chmod install script: %w", err)
 	}
 
 	return nil
@@ -494,7 +493,7 @@ func copyInstallScript(spec PackageSpec, script string, local *string) error {
 func (s PackageSpec) hash() string {
 	h, err := hashstructure.Hash(s, nil)
 	if err != nil {
-		panic(errors.Wrap(err, "failed to compute hash of spec"))
+		panic(fmt.Errorf("failed to compute hash of spec: %w", err))
 	}
 
 	hash := strconv.FormatUint(h, 10)
@@ -550,7 +549,7 @@ func PackageZip(spec PackageSpec) error {
 
 		if err := addFileToZip(w, baseDir, pkgFile); err != nil {
 			p, _ := filepath.Abs(pkgFile.Source)
-			return errors.Wrapf(err, "failed adding file=%+v to zip", p)
+			return fmt.Errorf("failed adding file=%+v to zip: %w", p, err)
 		}
 	}
 
@@ -570,7 +569,7 @@ func PackageZip(spec PackageSpec) error {
 
 	// Write the zip file.
 	if err := ioutil.WriteFile(CreateDir(spec.OutputFile), buf.Bytes(), 0644); err != nil {
-		return errors.Wrap(err, "failed to write zip file")
+		return fmt.Errorf("failed to write zip file: %w", err)
 	}
 
 	// Any packages beginning with "tmp-" are temporary by nature so don't have
@@ -579,7 +578,10 @@ func PackageZip(spec PackageSpec) error {
 		return nil
 	}
 
-	return errors.Wrap(CreateSHA512File(spec.OutputFile), "failed to create .sha512 file")
+	if err := CreateSHA512File(spec.OutputFile); err != nil {
+		return fmt.Errorf("failed to create .sha512 file: %w", err)
+	}
+	return nil
 }
 
 // PackageTarGz packages a gzipped tar file.
@@ -619,7 +621,7 @@ func PackageTarGz(spec PackageSpec) error {
 		}
 
 		if err := addFileToTar(w, baseDir, pkgFile); err != nil {
-			return errors.Wrapf(err, "failed adding file=%+v to tar", pkgFile)
+			return fmt.Errorf("failed adding file=%+v to tar: %w", pkgFile, err)
 		}
 	}
 
@@ -636,7 +638,7 @@ func PackageTarGz(spec PackageSpec) error {
 		defer os.RemoveAll(tmpdir)
 
 		if err := addSymlinkToTar(tmpdir, w, baseDir, pkgFile); err != nil {
-			return errors.Wrapf(err, "failed adding file=%+v to tar", pkgFile)
+			return fmt.Errorf("failed adding file=%+v to tar: %w", pkgFile, err)
 		}
 	}
 
@@ -679,7 +681,11 @@ func PackageTarGz(spec PackageSpec) error {
 		return nil
 	}
 
-	return errors.Wrap(CreateSHA512File(spec.OutputFile), "failed to create .sha512 file")
+	if err := CreateSHA512File(spec.OutputFile); err != nil {
+		return fmt.Errorf("failed to create .sha512 file: %w", err)
+	}
+
+	return nil
 }
 
 func replaceFileArch(filename string, pkgFile PackageFile, arch string) (string, PackageFile) {
@@ -706,7 +712,7 @@ func runFPM(spec PackageSpec, packageType PackageType) error {
 	case RPM, Deb:
 		fpmPackageType = packageType.String()
 	default:
-		return errors.Errorf("unsupported package type=%v for runFPM", fpmPackageType)
+		return fmt.Errorf("unsupported package type=%v for runFPM", fpmPackageType)
 	}
 
 	if err := HaveDocker(); err != nil {
@@ -787,10 +793,13 @@ func runFPM(spec PackageSpec, packageType PackageType) error {
 	)
 
 	if err = dockerRun(args...); err != nil {
-		return errors.Wrap(err, "failed while running FPM in docker")
+		return fmt.Errorf("failed while running FPM in docker: %w", err)
 	}
 
-	return errors.Wrap(CreateSHA512File(spec.OutputFile), "failed to create .sha512 file")
+	if err = CreateSHA512File(spec.OutputFile); err != nil {
+		return fmt.Errorf("failed to create .sha512 file: %w", err)
+	}
+	return nil
 }
 
 func addUidGidEnvArgs(args []string) ([]string, error) {
@@ -800,7 +809,7 @@ func addUidGidEnvArgs(args []string) ([]string, error) {
 
 	info, err := GetDockerInfo()
 	if err != nil {
-		return args, errors.Wrap(err, "failed to get docker info")
+		return args, fmt.Errorf("failed to get docker info: %w", err)
 	}
 
 	uid, gid := os.Getuid(), os.Getgid()
@@ -1006,7 +1015,7 @@ func addSymlinkToTar(tmpdir string, ar *tar.Writer, baseDir string, pkgFile Pack
 // PackageDocker packages the Beat into a docker image.
 func PackageDocker(spec PackageSpec) error {
 	if err := HaveDocker(); err != nil {
-		return errors.Errorf("docker daemon required to build images: %s", err)
+		return fmt.Errorf("docker daemon required to build images: %s", err)
 	}
 
 	b, err := newDockerBuilder(spec)
diff --git a/dev-tools/mage/settings.go b/dev-tools/mage/settings.go
index 0fe010877f0..46ccf691502 100644
--- a/dev-tools/mage/settings.go
+++ b/dev-tools/mage/settings.go
@@ -18,6 +18,7 @@
 package mage
 
 import (
+	"errors"
 	"fmt"
 	"go/build"
 	"io/ioutil"
@@ -31,7 +32,6 @@ import (
 	"time"
 
 	"github.com/magefile/mage/sh"
-	"github.com/pkg/errors"
 	"golang.org/x/tools/go/vcs"
 
 	"github.com/elastic/beats/v7/dev-tools/mage/gotool"
@@ -108,22 +108,22 @@ func init() {
 	var err error
 	RaceDetector, err = strconv.ParseBool(EnvOr("RACE_DETECTOR", "false"))
 	if err != nil {
-		panic(errors.Wrap(err, "failed to parse RACE_DETECTOR env value"))
+		panic(fmt.Errorf("failed to parse RACE_DETECTOR env value: %w", err))
 	}
 
 	TestCoverage, err = strconv.ParseBool(EnvOr("TEST_COVERAGE", "false"))
 	if err != nil {
-		panic(errors.Wrap(err, "failed to parse TEST_COVERAGE env value"))
+		panic(fmt.Errorf("failed to parse TEST_COVERAGE env value: %w", err))
 	}
 
 	Snapshot, err = strconv.ParseBool(EnvOr("SNAPSHOT", "false"))
 	if err != nil {
-		panic(errors.Wrap(err, "failed to parse SNAPSHOT env value"))
+		panic(fmt.Errorf("failed to parse SNAPSHOT env value: %w", err))
 	}
 
 	DevBuild, err = strconv.ParseBool(EnvOr("DEV", "false"))
 	if err != nil {
-		panic(errors.Wrap(err, "failed to parse DEV env value"))
+		panic(fmt.Errorf("failed to parse DEV env value: %w", err))
 	}
 
 	versionQualifier, versionQualified = os.LookupEnv("VERSION_QUALIFIER")
@@ -448,7 +448,7 @@ func getBuildVariableSources() *BuildVariableSources {
 		return buildVariableSources
 	}
 
-	panic(errors.Errorf("magefile must call devtools.SetBuildVariableSources() "+
+	panic(fmt.Errorf("magefile must call devtools.SetBuildVariableSources() "+
 		"because it is not an elastic beat (repo=%+v)", repo.RootImportPath))
 }
 
@@ -493,7 +493,7 @@ func (s *BuildVariableSources) GetBeatVersion() (string, error) {
 
 	data, err := ioutil.ReadFile(file)
 	if err != nil {
-		return "", errors.Wrapf(err, "failed to read beat version file=%v", file)
+		return "", fmt.Errorf("failed to read beat version file=%v: %w", file, err)
 	}
 
 	if s.BeatVersionParser == nil {
@@ -511,7 +511,7 @@ func (s *BuildVariableSources) GetGoVersion() (string, error) {
 
 	data, err := ioutil.ReadFile(file)
 	if err != nil {
-		return "", errors.Wrapf(err, "failed to read go version file=%v", file)
+		return "", fmt.Errorf("failed to read go version file=%v: %w", file, err)
 	}
 
 	if s.GoVersionParser == nil {
@@ -529,7 +529,7 @@ func (s *BuildVariableSources) GetDocBranch() (string, error) {
 
 	data, err := ioutil.ReadFile(file)
 	if err != nil {
-		return "", errors.Wrapf(err, "failed to read doc branch file=%v", file)
+		return "", fmt.Errorf("failed to read doc branch file=%v: %w", file, err)
 	}
 
 	if s.DocBranchParser == nil {
@@ -645,7 +645,7 @@ func getProjectRepoInfoWithModules() (*ProjectRepoInfo, error) {
 	}
 
 	if rootDir == "" {
-		return nil, errors.Errorf("failed to find root dir of module file: %v", errs)
+		return nil, fmt.Errorf("failed to find root dir of module file: %v", errs)
 	}
 
 	rootImportPath, err := gotool.GetModuleName()
@@ -699,12 +699,12 @@ func getProjectRepoInfoUnderGopath() (*ProjectRepoInfo, error) {
 	}
 
 	if rootDir == "" {
-		return nil, errors.Errorf("error while determining root directory: %v", errs)
+		return nil, fmt.Errorf("error while determining root directory: %v", errs)
 	}
 
 	subDir, err := filepath.Rel(rootDir, cwd)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get relative path to repo root")
+		return nil, fmt.Errorf("failed to get relative path to repo root: %w", err)
 	}
 
 	rootImportPath, err := gotool.GetModuleName()
@@ -756,7 +756,7 @@ func listSrcGOPATHs() ([]string, error) {
 	}
 
 	if len(srcDirs) == 0 {
-		return srcDirs, errors.Errorf("failed to find any GOPATH %v", errs)
+		return srcDirs, fmt.Errorf("failed to find any GOPATH %v", errs)
 	}
 
 	return srcDirs, nil
diff --git a/dev-tools/mage/target/dashboards/dashboards.go b/dev-tools/mage/target/dashboards/dashboards.go
index c993b8bacc0..b7ac6685c31 100644
--- a/dev-tools/mage/target/dashboards/dashboards.go
+++ b/dev-tools/mage/target/dashboards/dashboards.go
@@ -18,8 +18,9 @@
 package dashboards
 
 import (
+	"errors"
+
 	"github.com/magefile/mage/mg"
-	"github.com/pkg/errors"
 
 	devtools "github.com/elastic/beats/v7/dev-tools/mage"
 )
diff --git a/filebeat/registrar/registrar.go b/filebeat/registrar/registrar.go
index c7043da249c..3ba8427e55f 100644
--- a/filebeat/registrar/registrar.go
+++ b/filebeat/registrar/registrar.go
@@ -23,8 +23,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/filebeat/input/file"
 	"github.com/elastic/beats/v7/libbeat/statestore"
 	"github.com/elastic/beats/v7/libbeat/statestore/backend"
@@ -102,7 +100,7 @@ func (r *Registrar) GetStates() []file.State {
 func (r *Registrar) loadStates() error {
 	states, err := readStatesFrom(r.store)
 	if err != nil {
-		return errors.Wrap(err, "can not load filebeat registry state")
+		return fmt.Errorf("can not load filebeat registry state: %w", err)
 	}
 
 	r.states.SetStates(states)
diff --git a/libbeat/api/make_listener_posix.go b/libbeat/api/make_listener_posix.go
index f2a52da3dc7..5bfd17fa0b8 100644
--- a/libbeat/api/make_listener_posix.go
+++ b/libbeat/api/make_listener_posix.go
@@ -20,12 +20,11 @@
 package api
 
 import (
+	"errors"
 	"fmt"
 	"net"
 	"os"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/api/npipe"
 )
 
@@ -53,10 +52,9 @@ func makeListener(cfg Config) (net.Listener, error) {
 	if network == "unix" {
 		if _, err := os.Stat(path); !os.IsNotExist(err) {
 			if err := os.Remove(path); err != nil {
-				return nil, errors.Wrapf(
-					err,
-					"cannot remove existing unix socket file at location %s",
-					path,
+				return nil, fmt.Errorf(
+					"cannot remove existing unix socket file at location %s: %w",
+					path, err,
 				)
 			}
 		}
@@ -70,11 +68,11 @@ func makeListener(cfg Config) (net.Listener, error) {
 	// Ensure file mode
 	if network == "unix" {
 		if err := os.Chmod(path, socketFileMode); err != nil {
-			return nil, errors.Wrapf(
-				err,
-				"could not set mode %d for unix socket file at location %s",
+			return nil, fmt.Errorf(
+				"could not set mode %d for unix socket file at location %s: %w",
 				socketFileMode,
 				path,
+				err,
 			)
 		}
 	}
diff --git a/libbeat/api/make_listener_windows.go b/libbeat/api/make_listener_windows.go
index 4f72fcfec2d..3fb5a301da0 100644
--- a/libbeat/api/make_listener_windows.go
+++ b/libbeat/api/make_listener_windows.go
@@ -20,11 +20,10 @@
 package api
 
 import (
+	"errors"
 	"fmt"
 	"net"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/api/npipe"
 )
 
@@ -40,7 +39,7 @@ func makeListener(cfg Config) (net.Listener, error) {
 		if len(cfg.SecurityDescriptor) == 0 {
 			sd, err = npipe.DefaultSD(cfg.User)
 			if err != nil {
-				return nil, errors.Wrap(err, "cannot generate security descriptor for the named pipe")
+				return nil, fmt.Errorf("cannot generate security descriptor for the named pipe: %w", err)
 			}
 		} else {
 			sd = cfg.SecurityDescriptor
diff --git a/libbeat/tests/compose/wrapper.go b/libbeat/tests/compose/wrapper.go
index a0c40afd6de..0649488c621 100644
--- a/libbeat/tests/compose/wrapper.go
+++ b/libbeat/tests/compose/wrapper.go
@@ -36,7 +36,6 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/elastic-agent-autodiscover/docker"
 )
@@ -149,7 +148,11 @@ func (d *wrapperDriver) LockFile() string {
 }
 
 func (d *wrapperDriver) Close() error {
-	return errors.Wrap(d.client.Close(), "failed to close wrapper driver")
+	err := d.client.Close()
+	if err != nil {
+		return fmt.Errorf("failed to close wrapper driver: %w", err)
+	}
+	return nil
 }
 
 func (d *wrapperDriver) cmd(ctx context.Context, command string, arg ...string) *exec.Cmd {
@@ -231,7 +234,7 @@ func writeToContainer(ctx context.Context, cli *client.Client, id, filename, con
 	opts := types.CopyToContainerOptions{}
 	err = cli.CopyToContainer(ctx, id, filepath.Dir(filename), bytes.NewReader(buf.Bytes()), opts)
 	if err != nil {
-		return errors.Wrapf(err, "failed to copy environment to container %s", id)
+		return fmt.Errorf("failed to copy environment to container %s: %w", id, err)
 	}
 	return nil
 }
diff --git a/metricbeat/helper/dialer/dialer_posix.go b/metricbeat/helper/dialer/dialer_posix.go
index 04651ab1ea4..0e66e82b2b7 100644
--- a/metricbeat/helper/dialer/dialer_posix.go
+++ b/metricbeat/helper/dialer/dialer_posix.go
@@ -20,11 +20,10 @@
 package dialer
 
 import (
+	"errors"
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/transport"
 )
 
diff --git a/metricbeat/helper/elastic/elastic.go b/metricbeat/helper/elastic/elastic.go
index e6cdea008f8..25fa5835434 100644
--- a/metricbeat/helper/elastic/elastic.go
+++ b/metricbeat/helper/elastic/elastic.go
@@ -21,8 +21,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/elastic-agent-libs/version"
@@ -145,7 +143,7 @@ func NewModule(base *mb.BaseModule, xpackEnabledMetricsets []string, optionalXpa
 		XPackEnabled bool `config:"xpack.enabled"`
 	}{}
 	if err := base.UnpackConfig(&config); err != nil {
-		return nil, errors.Wrapf(err, "could not unpack configuration for module %v", moduleName)
+		return nil, fmt.Errorf("could not unpack configuration for module %v: %w", moduleName, err)
 	}
 
 	// No special configuration is needed if xpack.enabled != true
@@ -155,7 +153,7 @@ func NewModule(base *mb.BaseModule, xpackEnabledMetricsets []string, optionalXpa
 
 	var raw mapstr.M
 	if err := base.UnpackConfig(&raw); err != nil {
-		return nil, errors.Wrapf(err, "could not unpack configuration for module %v", moduleName)
+		return nil, fmt.Errorf("could not unpack configuration for module %v: %w", moduleName, err)
 	}
 
 	// Ensure all required metricsets are enabled when xpack.enabled == true, and add any additional which are optional
@@ -190,12 +188,12 @@ func NewModule(base *mb.BaseModule, xpackEnabledMetricsets []string, optionalXpa
 
 	newConfig, err := conf.NewConfigFrom(raw)
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not create new configuration for module %v", moduleName)
+		return nil, fmt.Errorf("could not create new configuration for module %v: %w", moduleName, err)
 	}
 
 	newModule, err := base.WithConfig(*newConfig)
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not reconfigure module %v", moduleName)
+		return nil, fmt.Errorf("could not reconfigure module %v: %w", moduleName, err)
 	}
 
 	logger.Debugf("Configuration for module %v modified because xpack.enabled was set to true", moduleName)
diff --git a/metricbeat/helper/socket/netlink.go b/metricbeat/helper/socket/netlink.go
index 0037cca64f7..df1230f5421 100644
--- a/metricbeat/helper/socket/netlink.go
+++ b/metricbeat/helper/socket/netlink.go
@@ -20,11 +20,10 @@
 package socket
 
 import (
+	"fmt"
 	"os"
 	"sync/atomic"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/gosigar/sys/linux"
 )
 
@@ -48,7 +47,7 @@ func (session *NetlinkSession) GetSocketList() ([]*linux.InetDiagMsg, error) {
 	req.Header.Seq = atomic.AddUint32(&session.seq, 1)
 	sockets, err := linux.NetlinkInetDiagWithBuf(req, session.readBuffer, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed requesting socket dump")
+		return nil, fmt.Errorf("failed requesting socket dump: %w", err)
 	}
 	return sockets, nil
 }
diff --git a/metricbeat/helper/sql/sql.go b/metricbeat/helper/sql/sql.go
index 80e59779adc..90ba5d96062 100644
--- a/metricbeat/helper/sql/sql.go
+++ b/metricbeat/helper/sql/sql.go
@@ -26,8 +26,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
@@ -48,14 +46,14 @@ type sqlRow interface {
 func NewDBClient(driver, uri string, l *logp.Logger) (*DbClient, error) {
 	dbx, err := sql.Open(switchDriverName(driver), uri)
 	if err != nil {
-		return nil, errors.Wrap(err, "opening connection")
+		return nil, fmt.Errorf("opening connection: %w", err)
 	}
 	err = dbx.Ping()
 	if err != nil {
 		if closeErr := dbx.Close(); closeErr != nil {
-			return nil, errors.Wrapf(err, "failed to close with %s, after connection test failed", closeErr)
+			return nil, fmt.Errorf("failed to close with %s, after connection test failed: %w", closeErr, err)
 		}
-		return nil, errors.Wrap(err, "testing connection")
+		return nil, fmt.Errorf("testing connection: %w", err)
 	}
 
 	return &DbClient{DB: dbx, logger: l}, nil
@@ -76,7 +74,7 @@ func (d *DbClient) fetchTableMode(rows sqlRow) ([]mapstr.M, error) {
 	// https://stackoverflow.com/questions/23507531/is-golangs-sql-package-incapable-of-ad-hoc-exploratory-queries/23507765#23507765
 	cols, err := rows.Columns()
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting columns")
+		return nil, fmt.Errorf("error getting columns: %w", err)
 	}
 
 	for k, v := range cols {
@@ -92,7 +90,7 @@ func (d *DbClient) fetchTableMode(rows sqlRow) ([]mapstr.M, error) {
 	for rows.Next() {
 		err = rows.Scan(vals...)
 		if err != nil {
-			d.logger.Debug(errors.Wrap(err, "error trying to scan rows"))
+			d.logger.Debug(fmt.Errorf("error trying to scan rows: %w", err))
 			continue
 		}
 
@@ -107,7 +105,7 @@ func (d *DbClient) fetchTableMode(rows sqlRow) ([]mapstr.M, error) {
 	}
 
 	if err = rows.Err(); err != nil {
-		d.logger.Debug(errors.Wrap(err, "error trying to read rows"))
+		d.logger.Debug(fmt.Errorf("error trying to read rows: %w", err))
 	}
 
 	return rr, nil
@@ -131,7 +129,7 @@ func (d *DbClient) fetchVariableMode(rows sqlRow) (mapstr.M, error) {
 		var val interface{}
 		err := rows.Scan(&key, &val)
 		if err != nil {
-			d.logger.Debug(errors.Wrap(err, "error trying to scan rows"))
+			d.logger.Debug(fmt.Errorf("error trying to scan rows: %w", err))
 			continue
 		}
 
@@ -140,7 +138,7 @@ func (d *DbClient) fetchVariableMode(rows sqlRow) (mapstr.M, error) {
 	}
 
 	if err := rows.Err(); err != nil {
-		d.logger.Debug(errors.Wrap(err, "error trying to read rows"))
+		d.logger.Debug(fmt.Errorf("error trying to read rows: %w", err))
 	}
 
 	r := mapstr.M{}
diff --git a/metricbeat/helper/windows/pdh/pdh_query_windows.go b/metricbeat/helper/windows/pdh/pdh_query_windows.go
index 44e86637346..3706edbf85c 100644
--- a/metricbeat/helper/windows/pdh/pdh_query_windows.go
+++ b/metricbeat/helper/windows/pdh/pdh_query_windows.go
@@ -20,6 +20,8 @@
 package pdh
 
 import (
+	"errors"
+	"fmt"
 	"regexp"
 	"runtime"
 	"strings"
@@ -27,8 +29,6 @@ import (
 	"unsafe"
 
 	"golang.org/x/sys/windows"
-
-	"github.com/pkg/errors"
 )
 
 var (
@@ -195,10 +195,10 @@ func (q *Query) GetFormattedCounterValues() (map[string][]CounterValue, error) {
 func (q *Query) GetCountersAndInstances(objectName string) ([]string, []string, error) {
 	counters, instances, err := PdhEnumObjectItems(objectName)
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "Unable to retrieve counter and instance list for %s", objectName)
+		return nil, nil, fmt.Errorf("Unable to retrieve counter and instance list for %s: %w", objectName, err)
 	}
 	if len(counters) == 0 && len(instances) == 0 {
-		return nil, nil, errors.Errorf("Unable to retrieve counter and instance list for %s", objectName)
+		return nil, nil, fmt.Errorf("Unable to retrieve counter and instance list for %s", objectName)
 	}
 	return UTF16ToStringArray(counters), UTF16ToStringArray(instances), nil
 }
@@ -333,7 +333,7 @@ func getCounterValue(counter *Counter) CounterValue {
 			counterValue.Measurement = value.Value
 		}
 	default:
-		counterValue.Err.Error = errors.Errorf("initialization failed: format '%#v' "+
+		counterValue.Err.Error = fmt.Errorf("initialization failed: format '%#v' "+
 			"for instance '%s' is invalid (must be PdhFmtDouble, PdhFmtLarge or PdhFmtLong)",
 			counter.format, counter.instanceName)
 	}
diff --git a/metricbeat/module/apache/status/status.go b/metricbeat/module/apache/status/status.go
index 012e08b91ac..472e4fcb3d5 100644
--- a/metricbeat/module/apache/status/status.go
+++ b/metricbeat/module/apache/status/status.go
@@ -19,7 +19,7 @@
 package status
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/fleetmode"
 	"github.com/elastic/beats/v7/metricbeat/helper"
@@ -87,7 +87,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	scanner, err := m.http.FetchScanner()
 	if err != nil {
-		return errors.Wrap(err, "error fetching data")
+		return fmt.Errorf("error fetching data: %w", err)
 	}
 
 	data, _ := eventMapping(scanner, m.Host())
diff --git a/metricbeat/module/ceph/cluster_status/cluster_status.go b/metricbeat/module/ceph/cluster_status/cluster_status.go
index 69c11a084f3..786bde0c9a5 100644
--- a/metricbeat/module/ceph/cluster_status/cluster_status.go
+++ b/metricbeat/module/ceph/cluster_status/cluster_status.go
@@ -18,7 +18,7 @@
 package cluster_status
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -70,12 +70,12 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	content, err := m.HTTP.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 
 	events, err := eventsMapping(content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	for _, event := range events {
diff --git a/metricbeat/module/ceph/mgr_cluster_disk/data.go b/metricbeat/module/ceph/mgr_cluster_disk/data.go
index e2e808cbc08..4f41ba05d79 100644
--- a/metricbeat/module/ceph/mgr_cluster_disk/data.go
+++ b/metricbeat/module/ceph/mgr_cluster_disk/data.go
@@ -18,7 +18,7 @@
 package mgr_cluster_disk
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/module/ceph/mgr"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -36,7 +36,7 @@ func eventMapping(content []byte) (mapstr.M, error) {
 	var response DfResponse
 	err := mgr.UnmarshalResponse(content, &response)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not get response data")
+		return nil, fmt.Errorf("could not get response data: %w", err)
 	}
 
 	return mapstr.M{
diff --git a/metricbeat/module/docker/network_summary/helper.go b/metricbeat/module/docker/network_summary/helper.go
index 63cb5793d44..694178b6147 100644
--- a/metricbeat/module/docker/network_summary/helper.go
+++ b/metricbeat/module/docker/network_summary/helper.go
@@ -29,7 +29,6 @@ import (
 	"time"
 
 	"github.com/docker/docker/client"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/go-sysinfo"
 
@@ -55,19 +54,23 @@ func fetchContainerNetStats(client *client.Client, timeout time.Duration, contai
 
 	inspect, err := client.ContainerInspect(ctx, container)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error fetching stats for container %s", container)
+		return nil, fmt.Errorf("error fetching stats for container %s: %w", container, err)
 	}
 	rootPID := inspect.ContainerJSONBase.State.Pid
 
 	proc, err := sysinfo.Process(rootPID)
+	if err != nil {
+		return nil, fmt.Errorf("cannot fetch process information for PID %d: %w", rootPID, err)
+	}
+
 	procNet, ok := proc.(sysinfotypes.NetworkCounters)
 	if !ok {
-		return nil, errors.Wrapf(err, "cannot fetch network counters for PID %d", rootPID)
+		return nil, fmt.Errorf("cannot fetch network counters for PID %d", rootPID)
 	}
 
 	counters, err := procNet.NetworkCounters()
 	if err != nil {
-		return &sysinfotypes.NetworkCountersInfo{}, errors.Wrapf(err, "error fetching network counters for PID %d", rootPID)
+		return &sysinfotypes.NetworkCountersInfo{}, fmt.Errorf("error fetching network counters for PID %d: %w", rootPID, err)
 	}
 
 	return counters, nil
@@ -78,7 +81,7 @@ func fetchContainerNetStats(client *client.Client, timeout time.Duration, contai
 func fetchNamespace(pid int) (int, error) {
 	nsLink, err := os.Readlink(filepath.Join("/proc/", fmt.Sprintf("%d", pid), "/ns/net"))
 	if err != nil {
-		return 0, errors.Wrap(err, "error reading network namespace link")
+		return 0, fmt.Errorf("error reading network namespace link: %w", err)
 	}
 	nsidString := nsRegex.FindString(nsLink)
 	// This is minor metadata, so don't consider it an error
@@ -88,7 +91,7 @@ func fetchNamespace(pid int) (int, error) {
 
 	nsID, err := strconv.Atoi(nsidString)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error converting %s to int", nsidString)
+		return 0, fmt.Errorf("error converting %s to int: %w", nsidString, err)
 	}
 	return nsID, nil
 }
diff --git a/metricbeat/module/docker/network_summary/network_summary.go b/metricbeat/module/docker/network_summary/network_summary.go
index 090869d1d8d..9753b449add 100644
--- a/metricbeat/module/docker/network_summary/network_summary.go
+++ b/metricbeat/module/docker/network_summary/network_summary.go
@@ -21,10 +21,10 @@ package network_summary
 
 import (
 	"context"
+	"fmt"
 	"runtime"
 
 	"github.com/docker/docker/client"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -86,7 +86,7 @@ func (m *MetricSet) Fetch(ctx context.Context, report mb.ReporterV2) error {
 
 	stats, err := docker.FetchStats(m.dockerClient, m.Module().Config().Timeout)
 	if err != nil {
-		return errors.Wrap(err, "failed to get docker stats")
+		return fmt.Errorf("failed to get docker stats: %w", err)
 	}
 
 	for _, myStats := range stats {
@@ -96,19 +96,19 @@ func (m *MetricSet) Fetch(ctx context.Context, report mb.ReporterV2) error {
 
 		inspect, err := m.dockerClient.ContainerInspect(ctx, myStats.Container.ID)
 		if err != nil {
-			return errors.Wrapf(err, "error fetching stats for container %s", myStats.Container.ID)
+			return fmt.Errorf("error fetching stats for container %s: %w", myStats.Container.ID, err)
 		}
 
 		rootPID := inspect.ContainerJSONBase.State.Pid
 
 		netNS, err := fetchNamespace(rootPID)
 		if err != nil {
-			return errors.Wrapf(err, "error fetching namespace for PID %d", rootPID)
+			return fmt.Errorf("error fetching namespace for PID %d: %w", rootPID, err)
 		}
 
 		networkStats, err := fetchContainerNetStats(m.dockerClient, m.Module().Config().Timeout, myStats.Container.ID)
 		if err != nil {
-			return errors.Wrap(err, "error fetching per-PID stats")
+			return fmt.Errorf("error fetching per-PID stats")
 		}
 
 		summary := network.MapProcNetCounters(networkStats)
diff --git a/metricbeat/module/elasticsearch/elasticsearch.go b/metricbeat/module/elasticsearch/elasticsearch.go
index 9cd316a41d3..00737472f2c 100644
--- a/metricbeat/module/elasticsearch/elasticsearch.go
+++ b/metricbeat/module/elasticsearch/elasticsearch.go
@@ -19,6 +19,7 @@ package elasticsearch
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/url"
 	"strconv"
@@ -26,8 +27,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/helper/elastic"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -390,7 +389,7 @@ func GetIndicesSettings(http *helper.HTTP, resetURI string) (map[string]IndexSet
 	content, err := fetchPath(http, resetURI, "*/_settings", "filter_path=*.settings.index.hidden&expand_wildcards=all")
 
 	if err != nil {
-		return nil, errors.Wrap(err, "could not fetch indices settings")
+		return nil, fmt.Errorf("could not fetch indices settings: %w", err)
 	}
 
 	var resp map[string]struct {
@@ -403,7 +402,7 @@ func GetIndicesSettings(http *helper.HTTP, resetURI string) (map[string]IndexSet
 
 	err = json.Unmarshal(content, &resp)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not parse indices settings response")
+		return nil, fmt.Errorf("could not parse indices settings response: %w", err)
 	}
 
 	ret := make(map[string]IndexSettings, len(resp))
@@ -604,7 +603,7 @@ func (l *License) ToMapStr() mapstr.M {
 func getSettingGroup(allSettings mapstr.M, groupKey string) (mapstr.M, error) {
 	hasSettingGroup, err := allSettings.HasKey(groupKey)
 	if err != nil {
-		return nil, errors.Wrap(err, "failure to determine if "+groupKey+" settings exist")
+		return nil, fmt.Errorf("failure to determine if "+groupKey+" settings exist: %w", err)
 	}
 
 	if !hasSettingGroup {
@@ -613,12 +612,12 @@ func getSettingGroup(allSettings mapstr.M, groupKey string) (mapstr.M, error) {
 
 	settings, err := allSettings.GetValue(groupKey)
 	if err != nil {
-		return nil, errors.Wrap(err, "failure to extract "+groupKey+" settings")
+		return nil, fmt.Errorf("failure to extract "+groupKey+" settings: %w", err)
 	}
 
 	v, ok := settings.(map[string]interface{})
 	if !ok {
-		return nil, errors.Wrap(err, groupKey+" settings are not a map")
+		return nil, fmt.Errorf(groupKey + " settings are not a map")
 	}
 
 	return mapstr.M(v), nil
diff --git a/metricbeat/module/haproxy/info/data.go b/metricbeat/module/haproxy/info/data.go
index b52c3fe9c48..d4cf9700269 100644
--- a/metricbeat/module/haproxy/info/data.go
+++ b/metricbeat/module/haproxy/info/data.go
@@ -18,7 +18,7 @@
 package info
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstrstr"
@@ -174,7 +174,7 @@ func eventMapping(info *haproxy.Info, r mb.ReporterV2) (mb.Event, error) {
 			// Convert this value to a float between 0.0 and 1.0
 			fval, err := strconv.ParseFloat(f.Interface().(string), 64)
 			if err != nil {
-				return mb.Event{}, errors.Wrap(err, "error getting IdlePct")
+				return mb.Event{}, fmt.Errorf("error getting IdlePct: %w", err)
 			}
 			source[typeOfT.Field(i).Name] = strconv.FormatFloat(fval/float64(100), 'f', 2, 64)
 		} else if typeOfT.Field(i).Name == "Memmax_MB" {
@@ -182,7 +182,7 @@ func eventMapping(info *haproxy.Info, r mb.ReporterV2) (mb.Event, error) {
 			val, err := strconv.Atoi(strings.TrimSpace(f.Interface().(string)))
 			if err != nil {
 				r.Error(err)
-				return mb.Event{}, errors.Wrap(err, "error getting Memmax_MB")
+				return mb.Event{}, fmt.Errorf("error getting Memmax_MB: %w", err)
 			}
 			source[typeOfT.Field(i).Name] = strconv.Itoa((val * 1024 * 1024))
 		} else {
@@ -201,7 +201,7 @@ func eventMapping(info *haproxy.Info, r mb.ReporterV2) (mb.Event, error) {
 
 	fields, err := schema.Apply(source)
 	if err != nil {
-		return event, errors.Wrap(err, "error applying schema")
+		return event, fmt.Errorf("error applying schema: %w", err)
 	}
 	if processID, err := fields.GetValue("pid"); err == nil {
 		event.RootFields.Put("process.pid", processID)
diff --git a/metricbeat/module/haproxy/info/info.go b/metricbeat/module/haproxy/info/info.go
index b875f05e718..027daf8fe73 100644
--- a/metricbeat/module/haproxy/info/info.go
+++ b/metricbeat/module/haproxy/info/info.go
@@ -18,7 +18,7 @@
 package info
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -57,17 +57,17 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	hapc, err := haproxy.NewHaproxyClient(m.HostData().URI, m.BaseMetricSet)
 	if err != nil {
-		return errors.Wrap(err, "failed creating haproxy client")
+		return fmt.Errorf("failed creating haproxy client: %w", err)
 	}
 
 	res, err := hapc.GetInfo()
 	if err != nil {
-		return errors.Wrap(err, "failed fetching haproxy info")
+		return fmt.Errorf("failed fetching haproxy info: %w", err)
 	}
 
 	event, err := eventMapping(res, reporter)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 	reporter.Event(event)
 	return nil
diff --git a/metricbeat/module/jolokia/jmx/config.go b/metricbeat/module/jolokia/jmx/config.go
index 23d7b18a5e2..337f0960011 100644
--- a/metricbeat/module/jolokia/jmx/config.go
+++ b/metricbeat/module/jolokia/jmx/config.go
@@ -19,13 +19,12 @@ package jmx
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"regexp"
 	"sort"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
@@ -395,7 +394,7 @@ func (pc *JolokiaHTTPGetFetcher) EventMapping(content []byte, mapping AttributeM
 
 	// When we use GET, the response is a single Entry
 	if err := json.Unmarshal(content, &singleEntry); err != nil {
-		return nil, errors.Wrapf(err, "failed to unmarshal jolokia JSON response '%v'", string(content))
+		return nil, fmt.Errorf("failed to unmarshal jolokia JSON response '%v': %w", string(content), err)
 	}
 
 	return eventMapping([]Entry{singleEntry}, mapping)
@@ -517,8 +516,7 @@ func (pc *JolokiaHTTPPostFetcher) EventMapping(content []byte, mapping Attribute
 
 	// When we use POST, the response is an array of Entry objects
 	if err := json.Unmarshal(content, &entries); err != nil {
-
-		return nil, errors.Wrapf(err, "failed to unmarshal jolokia JSON response '%v'", string(content))
+		return nil, fmt.Errorf("failed to unmarshal jolokia JSON response '%v': %w", string(content), err)
 	}
 
 	return eventMapping(entries, mapping)
diff --git a/metricbeat/module/kafka/consumergroup/consumergroup.go b/metricbeat/module/kafka/consumergroup/consumergroup.go
index acce0b39d20..5fa41b13f01 100644
--- a/metricbeat/module/kafka/consumergroup/consumergroup.go
+++ b/metricbeat/module/kafka/consumergroup/consumergroup.go
@@ -20,8 +20,6 @@ package consumergroup
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/module/kafka"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -81,7 +79,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	broker, err := m.Connect()
 	if err != nil {
-		return errors.Wrap(err, "error in connect")
+		return fmt.Errorf("error in connect: %w", err)
 	}
 	defer broker.Close()
 
@@ -114,7 +112,7 @@ func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	}
 	err = fetchGroupInfo(emitEvent, broker, m.groups.pred(), m.topics.pred())
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 
 	return nil
diff --git a/metricbeat/module/kafka/consumergroup/consumergroup_integration_test.go b/metricbeat/module/kafka/consumergroup/consumergroup_integration_test.go
index db3423c8c3d..aafb5250499 100644
--- a/metricbeat/module/kafka/consumergroup/consumergroup_integration_test.go
+++ b/metricbeat/module/kafka/consumergroup/consumergroup_integration_test.go
@@ -20,12 +20,12 @@
 package consumergroup
 
 import (
+	"fmt"
 	"io"
 	"testing"
 	"time"
 
 	saramacluster "github.com/bsm/sarama-cluster"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/libbeat/tests/compose"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -47,7 +47,7 @@ func TestData(t *testing.T) {
 
 	c, err := startConsumer(t, service.HostForPort(9092), "metricbeat-test")
 	if err != nil {
-		t.Fatal(errors.Wrap(err, "starting kafka consumer"))
+		t.Fatal(fmt.Errorf("starting kafka consumer: %w", err))
 	}
 	defer c.Close()
 
@@ -70,7 +70,7 @@ func TestFetch(t *testing.T) {
 
 	c, err := startConsumer(t, service.HostForPort(9092), "metricbeat-test")
 	if err != nil {
-		t.Fatal(errors.Wrap(err, "starting kafka consumer"))
+		t.Fatal(fmt.Errorf("starting kafka consumer: %w", err))
 	}
 	defer c.Close()
 
diff --git a/metricbeat/module/kafka/partition/partition.go b/metricbeat/module/kafka/partition/partition.go
index c0372b32361..486c9a79e24 100644
--- a/metricbeat/module/kafka/partition/partition.go
+++ b/metricbeat/module/kafka/partition/partition.go
@@ -18,12 +18,11 @@
 package partition
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/Shopify/sarama"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 	"github.com/elastic/beats/v7/metricbeat/module/kafka"
@@ -78,13 +77,13 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	broker, err := m.Connect()
 	if err != nil {
-		return errors.Wrap(err, "error in connect")
+		return fmt.Errorf("error in connect: %w", err)
 	}
 	defer broker.Close()
 
 	topics, err := broker.GetTopicsMetadata(m.topics...)
 	if err != nil {
-		return errors.Wrap(err, "error getting topic metadata")
+		return fmt.Errorf("error getting topic metadata: %w", err)
 	}
 	if len(topics) == 0 {
 		debugf("no topic could be read, check ACLs")
@@ -190,12 +189,12 @@ func queryOffsetRange(
 ) (int64, int64, bool, error) {
 	oldest, err := b.PartitionOffset(replicaID, topic, partition, sarama.OffsetOldest)
 	if err != nil {
-		return -1, -1, false, errors.Wrap(err, "failed to get oldest offset")
+		return -1, -1, false, fmt.Errorf("failed to get oldest offset: %w", err)
 	}
 
 	newest, err := b.PartitionOffset(replicaID, topic, partition, sarama.OffsetNewest)
 	if err != nil {
-		return -1, -1, false, errors.Wrap(err, "failed to get newest offset")
+		return -1, -1, false, fmt.Errorf("failed to get newest offset: %w", err)
 	}
 
 	okOld := oldest != -1
diff --git a/metricbeat/module/kibana/settings/data.go b/metricbeat/module/kibana/settings/data.go
index 55c6860e9f6..fc47e8a4839 100644
--- a/metricbeat/module/kibana/settings/data.go
+++ b/metricbeat/module/kibana/settings/data.go
@@ -19,8 +19,7 @@ package settings
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper/elastic"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -34,7 +33,7 @@ func eventMapping(r mb.ReporterV2, content []byte) error {
 	var data map[string]interface{}
 	err := json.Unmarshal(content, &data)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing Kibana API response")
+		return fmt.Errorf("failure parsing Kibana API response: %w", err)
 	}
 
 	schema := s.Schema{
diff --git a/metricbeat/module/kibana/status/data.go b/metricbeat/module/kibana/status/data.go
index f02b2812d0b..3f975323a9e 100644
--- a/metricbeat/module/kibana/status/data.go
+++ b/metricbeat/module/kibana/status/data.go
@@ -19,8 +19,7 @@ package status
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -60,7 +59,7 @@ func eventMapping(r mb.ReporterV2, content []byte, isXpack bool) error {
 	var data map[string]interface{}
 	err := json.Unmarshal(content, &data)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing Kibana Status API response")
+		return fmt.Errorf("failure parsing Kibana Status API response: %w", err)
 	}
 
 	dataFields, _ := schema.Apply(data)
diff --git a/metricbeat/module/kvm/dommemstat/dommemstat.go b/metricbeat/module/kvm/dommemstat/dommemstat.go
index 2714204d0af..f8585deb533 100644
--- a/metricbeat/module/kvm/dommemstat/dommemstat.go
+++ b/metricbeat/module/kvm/dommemstat/dommemstat.go
@@ -18,6 +18,8 @@
 package dommemstat
 
 import (
+	"errors"
+	"fmt"
 	"net"
 	"net/url"
 	"time"
@@ -25,8 +27,6 @@ import (
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 
-	"github.com/pkg/errors"
-
 	"github.com/digitalocean/go-libvirt"
 	"github.com/digitalocean/go-libvirt/libvirttest"
 
@@ -101,7 +101,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 		c, err = net.DialTimeout(u.Scheme, address, m.Timeout)
 		if err != nil {
-			return errors.Wrapf(err, "cannot connect to %v", u)
+			return fmt.Errorf("cannot connect to %v: %w", u, err)
 		}
 	}
 
@@ -109,11 +109,11 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	l := libvirt.New(c)
 	if err = l.Connect(); err != nil {
-		return errors.Wrap(err, "error connecting to libvirtd")
+		return fmt.Errorf("error connecting to libvirtd: %w", err)
 	}
 	defer func() {
 		if err = l.Disconnect(); err != nil {
-			msg := errors.Wrap(err, "failed to disconnect")
+			msg := fmt.Errorf("failed to disconnect: %w", err)
 			report.Error(msg)
 			m.Logger().Error(msg)
 		}
@@ -121,20 +121,20 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	domains, err := l.Domains()
 	if err != nil {
-		return errors.Wrap(err, "error listing domains")
+		return fmt.Errorf("error listing domains: %w", err)
 	}
 
 	for _, d := range domains {
 		gotDomainMemoryStats, err := l.DomainMemoryStats(d, maximumStats, flags)
 		if err != nil {
-			msg := errors.Wrapf(err, "error fetching memory stats for domain %s", d.Name)
+			msg := fmt.Errorf("error fetching memory stats for domain %s: %w", d.Name, err)
 			report.Error(msg)
 			m.Logger().Error(msg)
 			continue
 		}
 
 		if len(gotDomainMemoryStats) == 0 {
-			msg := errors.Errorf("no memory stats for domain %s", d.Name)
+			msg := fmt.Errorf("no memory stats for domain %s", d.Name)
 			report.Error(msg)
 			m.Logger().Error(msg)
 			continue
diff --git a/metricbeat/module/kvm/status/status.go b/metricbeat/module/kvm/status/status.go
index fdbb7a22b7a..320fe4a5df0 100644
--- a/metricbeat/module/kvm/status/status.go
+++ b/metricbeat/module/kvm/status/status.go
@@ -18,12 +18,11 @@
 package status
 
 import (
+	"fmt"
 	"net"
 	"net/url"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/digitalocean/go-libvirt"
 	"github.com/digitalocean/go-libvirt/libvirttest"
 
@@ -90,7 +89,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 		c, err = net.DialTimeout(u.Scheme, address, m.Timeout)
 		if err != nil {
-			return errors.Wrapf(err, "cannot connect to %v", u)
+			return fmt.Errorf("cannot connect to %v: %w", u, err)
 		}
 	}
 
@@ -98,11 +97,11 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	l := libvirt.New(c)
 	if err = l.Connect(); err != nil {
-		return errors.Wrap(err, "error connecting to libvirtd")
+		return fmt.Errorf("error connecting to libvirtd: %w", err)
 	}
 	defer func() {
 		if err = l.Disconnect(); err != nil {
-			msg := errors.Wrap(err, "failed to disconnect")
+			msg := fmt.Errorf("failed to disconnect: %w", err)
 			report.Error(msg)
 			m.Logger().Error(msg)
 		}
@@ -110,7 +109,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	domains, err := l.Domains()
 	if err != nil {
-		return errors.Wrap(err, "error listing domains")
+		return fmt.Errorf("error listing domains: %w", err)
 	}
 
 	for _, d := range domains {
diff --git a/metricbeat/module/linux/conntrack/conntrack.go b/metricbeat/module/linux/conntrack/conntrack.go
index 3970ff689c8..602a786b574 100644
--- a/metricbeat/module/linux/conntrack/conntrack.go
+++ b/metricbeat/module/linux/conntrack/conntrack.go
@@ -18,7 +18,8 @@
 package conntrack
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
+
 	"github.com/prometheus/procfs"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
@@ -63,11 +64,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	newFS, err := procfs.NewFS(m.mod.ResolveHostFS("/proc"))
 	if err != nil {
-		return errors.Wrapf(err, "error creating new Host FS at %s", m.mod.ResolveHostFS("/proc"))
+		return fmt.Errorf("error creating new Host FS at %s: %w", m.mod.ResolveHostFS("/proc"), err)
 	}
 	conntrackStats, err := newFS.ConntrackStat()
 	if err != nil {
-		return errors.Wrap(err, "error fetching conntrack stats")
+		return fmt.Errorf("error fetching conntrack stats: %w", err)
 	}
 
 	summedEvents := procfs.ConntrackStatEntry{}
diff --git a/metricbeat/module/linux/iostat/iostat.go b/metricbeat/module/linux/iostat/iostat.go
index f7143a37243..14604f8aea4 100644
--- a/metricbeat/module/linux/iostat/iostat.go
+++ b/metricbeat/module/linux/iostat/iostat.go
@@ -20,7 +20,7 @@
 package iostat
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -71,7 +71,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	IOstats, err := diskio.IOCounters(m.includeDevices...)
 	if err != nil {
-		return errors.Wrap(err, "disk io counters")
+		return fmt.Errorf("disk io counters: %w", err)
 	}
 
 	// Sample the current cpu counter
@@ -89,7 +89,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 		}
 		result, err := m.stats.CalcIOStatistics(counters)
 		if err != nil {
-			return errors.Wrap(err, "error calculating iostat")
+			return fmt.Errorf("error calculating iostat: %w", err)
 		}
 		IOstats := AddLinuxIOStat(result)
 		event.DeepUpdate(IOstats)
diff --git a/metricbeat/module/linux/ksm/data.go b/metricbeat/module/linux/ksm/data.go
index 3ceb42c5231..94055224ca0 100644
--- a/metricbeat/module/linux/ksm/data.go
+++ b/metricbeat/module/linux/ksm/data.go
@@ -18,10 +18,9 @@
 package ksm
 
 import (
+	"fmt"
 	"path/filepath"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/module/linux"
 )
 
@@ -40,37 +39,37 @@ func fetchKSMStats(ksmPath string) (ksmData, error) {
 	// ReadIntFromFile returns pretty verbose error strings, so omit errors.Wrap here
 	pshared, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "pages_shared"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from pages_shared")
+		return ksmData{}, fmt.Errorf("error reading from pages_shared: %w", err)
 	}
 
 	pSharing, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "pages_sharing"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from pages_sharing")
+		return ksmData{}, fmt.Errorf("error reading from pages_sharing: %w", err)
 	}
 
 	pUnshared, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "pages_unshared"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from pages_unshared")
+		return ksmData{}, fmt.Errorf("error reading from pages_unshared: %w", err)
 	}
 
 	pVolatile, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "pages_volatile"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from pages_volatile")
+		return ksmData{}, fmt.Errorf("error reading from pages_volatile: %w", err)
 	}
 
 	fScans, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "full_scans"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from full_scans")
+		return ksmData{}, fmt.Errorf("error reading from full_scans: %w", err)
 	}
 
 	stableChains, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "stable_node_chains"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from stable_node_chains")
+		return ksmData{}, fmt.Errorf("error reading from stable_node_chains: %w", err)
 	}
 
 	stableDups, err := linux.ReadIntFromFile(filepath.Join(ksmPath, "stable_node_dups"), 10)
 	if err != nil {
-		return ksmData{}, errors.Wrap(err, "error reading from stable_node_dups ")
+		return ksmData{}, fmt.Errorf("error reading from stable_node_dups : %w", err)
 	}
 
 	return ksmData{PagesShared: pshared, PagesSharing: pSharing, PagesUnshared: pUnshared,
diff --git a/metricbeat/module/linux/ksm/ksm.go b/metricbeat/module/linux/ksm/ksm.go
index abbd899cd8a..1bf344be184 100644
--- a/metricbeat/module/linux/ksm/ksm.go
+++ b/metricbeat/module/linux/ksm/ksm.go
@@ -18,7 +18,7 @@
 package ksm
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -62,7 +62,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	ksmData, err := fetchKSMStats(m.mod.ResolveHostFS("/sys/kernel/mm/ksm"))
 	if err != nil {
-		return errors.Wrap(err, "error fetching KSM stats")
+		return fmt.Errorf("error fetching KSM stats: %w", err)
 	}
 
 	report.Event(mb.Event{
diff --git a/metricbeat/module/linux/memory/data.go b/metricbeat/module/linux/memory/data.go
index de41ed5df00..dfc5f3276ae 100644
--- a/metricbeat/module/linux/memory/data.go
+++ b/metricbeat/module/linux/memory/data.go
@@ -23,8 +23,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/elastic-agent-libs/transform/typeconv"
 	util "github.com/elastic/elastic-agent-system-metrics/metric"
@@ -37,7 +35,7 @@ import (
 func FetchLinuxMemStats(baseMap mapstr.M, hostfs resolve.Resolver) error {
 	vmstat, err := GetVMStat(hostfs)
 	if err != nil {
-		return errors.Wrap(err, "error fetching VMStats")
+		return fmt.Errorf("error fetching VMStats: %w", err)
 	}
 
 	pageStats := mapstr.M{}
@@ -55,7 +53,7 @@ func FetchLinuxMemStats(baseMap mapstr.M, hostfs resolve.Resolver) error {
 
 	thp, err := getHugePages(hostfs)
 	if err != nil {
-		return errors.Wrap(err, "error getting huge pages")
+		return fmt.Errorf("error getting huge pages: %w", err)
 	}
 	baseMap["hugepages"] = thp
 
@@ -71,12 +69,12 @@ func FetchLinuxMemStats(baseMap mapstr.M, hostfs resolve.Resolver) error {
 	// This way very similar metrics aren't split across different modules, even though Linux reports them in different places.
 	eventRaw, err := metrics.Get(hostfs)
 	if err != nil {
-		return errors.Wrap(err, "error fetching memory metrics")
+		return fmt.Errorf("error fetching memory metrics: %w", err)
 	}
 	swap := mapstr.M{}
 	err = typeconv.Convert(&swap, &eventRaw.Swap)
 	if err != nil {
-		return errors.Wrap(err, "error converting raw event")
+		return fmt.Errorf("error converting raw event: %w", err)
 	}
 
 	baseMap["swap"] = swap
@@ -122,7 +120,7 @@ func getHugePages(hostfs resolve.Resolver) (mapstr.M, error) {
 	// see https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt
 	table, err := memory.ParseMeminfo(hostfs)
 	if err != nil {
-		return nil, errors.Wrap(err, "error parsing meminfo")
+		return nil, fmt.Errorf("error parsing meminfo: %w", err)
 	}
 	thp := mapstr.M{}
 
@@ -168,7 +166,7 @@ func GetVMStat(hostfs resolve.Resolver) (map[string]uint64, error) {
 	vmstatFile := hostfs.ResolveHostFS("proc/vmstat")
 	content, err := os.ReadFile(vmstatFile)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error reading vmstat from %s", vmstatFile)
+		return nil, fmt.Errorf("error reading vmstat from %s: %w", vmstatFile, err)
 	}
 
 	// I'm not a fan of throwing stuff directly to maps, but this is a huge amount of kernel/config specific metrics, and we're the only consumer of this for now.
@@ -181,7 +179,7 @@ func GetVMStat(hostfs resolve.Resolver) (map[string]uint64, error) {
 
 		num, err := strconv.ParseUint(string(parts[1]), 10, 64)
 		if err != nil {
-			return nil, errors.Wrapf(err, "failed to parse value %s", parts[1])
+			return nil, fmt.Errorf("failed to parse value %s: %w", parts[1], err)
 		}
 		vmstat[parts[0]] = num
 
diff --git a/metricbeat/module/linux/memory/memory.go b/metricbeat/module/linux/memory/memory.go
index e74b8b36e60..01eef01cb4b 100644
--- a/metricbeat/module/linux/memory/memory.go
+++ b/metricbeat/module/linux/memory/memory.go
@@ -18,7 +18,7 @@
 package memory
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -61,7 +61,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	rootEvent := mapstr.M{}
 	err := FetchLinuxMemStats(rootEvent, m.mod)
 	if err != nil {
-		return errors.Wrap(err, "error fetching memory stats")
+		return fmt.Errorf("error fetching memory stats: %w", err)
 	}
 	report.Event(mb.Event{
 		MetricSetFields: rootEvent,
diff --git a/metricbeat/module/linux/pageinfo/pageinfo.go b/metricbeat/module/linux/pageinfo/pageinfo.go
index d32243812f2..fc1be3fca35 100644
--- a/metricbeat/module/linux/pageinfo/pageinfo.go
+++ b/metricbeat/module/linux/pageinfo/pageinfo.go
@@ -19,10 +19,9 @@ package pageinfo
 
 import (
 	"bufio"
+	"fmt"
 	"os"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -67,7 +66,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	fd, err := os.Open(pagePath)
 	if err != nil {
-		return errors.Wrap(err, "error opening file")
+		return fmt.Errorf("error opening file: %w", err)
 	}
 	defer fd.Close()
 
@@ -75,7 +74,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	zones, err := readPageFile(reader)
 	if err != nil {
-		return errors.Wrap(err, "error reading pagetypeinfo")
+		return fmt.Errorf("error reading pagetypeinfo: %w", err)
 	}
 
 	report.Event(mb.Event{
diff --git a/metricbeat/module/linux/pageinfo/reader.go b/metricbeat/module/linux/pageinfo/reader.go
index 9af65dfb1f7..39a5062f6d0 100644
--- a/metricbeat/module/linux/pageinfo/reader.go
+++ b/metricbeat/module/linux/pageinfo/reader.go
@@ -19,11 +19,10 @@ package pageinfo
 
 import (
 	"bufio"
+	"fmt"
 	"io"
 	"regexp"
 	"strconv"
-
-	"github.com/pkg/errors"
 )
 
 // zones represents raw pagetypeinfo data
@@ -83,7 +82,7 @@ func readPageFile(reader *bufio.Reader) (pageInfo, error) {
 		match := matches[0]
 		nodeLevel, err = strconv.ParseInt(string(match[1]), 10, 64)
 		if err != nil {
-			return pageInfo{}, errors.Wrapf(err, "error parsing node number: %s", string(match[1]))
+			return pageInfo{}, fmt.Errorf("error parsing node number: %s: %w", string(match[1]), err)
 		}
 		if nodes[nodeLevel].DMA == nil {
 			nodes[nodeLevel] = zones{
@@ -100,7 +99,7 @@ func readPageFile(reader *bufio.Reader) (pageInfo, error) {
 		for order, count := range match[4:] {
 			zoneOrders[order], err = strconv.ParseInt(string(count), 10, 64)
 			if err != nil {
-				return pageInfo{}, errors.Wrapf(err, "error parsing zone: %s", string(count))
+				return pageInfo{}, fmt.Errorf("error parsing zone: %s: %w", string(count), err)
 			}
 			nodes[nodeLevel].OrderSummary[order] += zoneOrders[order]
 			if zoneType == "DMA" {
diff --git a/metricbeat/module/linux/pressure/pressure.go b/metricbeat/module/linux/pressure/pressure.go
index 529fb69ed33..292dcd194a7 100644
--- a/metricbeat/module/linux/pressure/pressure.go
+++ b/metricbeat/module/linux/pressure/pressure.go
@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/pkg/errors"
 	"github.com/prometheus/procfs"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
@@ -75,7 +74,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	events, err := fetchLinuxPSIStats(m)
 	if err != nil {
-		return errors.Wrap(err, "error fetching PSI stats")
+		return fmt.Errorf("error fetching PSI stats: %w", err)
 	}
 
 	for _, event := range events {
@@ -92,13 +91,13 @@ func fetchLinuxPSIStats(m *MetricSet) ([]mapstr.M, error) {
 
 	procfs, err := procfs.NewFS(m.mod.ResolveHostFS("/proc"))
 	if err != nil {
-		return nil, errors.Wrapf(err, "error creating new Host FS at %s", m.mod.ResolveHostFS("/proc"))
+		return nil, fmt.Errorf("error creating new Host FS at %s: %w", m.mod.ResolveHostFS("/proc"), err)
 	}
 
 	for _, resource := range resources {
 		psiMetric, err := procfs.PSIStatsForResource(resource)
 		if err != nil {
-			return nil, errors.Wrap(err, "check that /proc/pressure is available, and/or enabled")
+			return nil, fmt.Errorf("check that /proc/pressure is available, and/or enabled: %w", err)
 		}
 
 		event := mapstr.M{
diff --git a/metricbeat/module/linux/rapl/rapl.go b/metricbeat/module/linux/rapl/rapl.go
index b0181f399bd..5dd823efc54 100644
--- a/metricbeat/module/linux/rapl/rapl.go
+++ b/metricbeat/module/linux/rapl/rapl.go
@@ -20,6 +20,7 @@
 package rapl
 
 import (
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
@@ -31,7 +32,6 @@ import (
 	"time"
 
 	"github.com/fearful-symmetry/gorapl/rapl"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/libbeat/common"
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
@@ -86,7 +86,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 	sys := base.Module().(resolve.Resolver)
 	CPUList, err := getMSRCPUs(sys)
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting list of CPUs to query")
+		return nil, fmt.Errorf("error getting list of CPUs to query: %w", err)
 	}
 
 	// check to see if msr-safe is installed
@@ -97,12 +97,12 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 			return nil, errors.New("no msr_safe device found. Is the kernel module loaded?")
 		}
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not check msr_safe device at %s", queryPath)
+			return nil, fmt.Errorf("could not check msr_safe device at %s: %w", queryPath, err)
 		}
 	} else {
 		user, err := user.Current()
 		if err != nil {
-			return nil, errors.Wrap(err, "error fetching user list")
+			return nil, fmt.Errorf("error fetching user list: %w", err)
 		}
 		if user.Uid != "0" {
 			return nil, errors.New("linux/rapl must run as root if not using msr-safe")
@@ -119,7 +119,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 		}
 		handler, err := rapl.CreateNewHandler(cpu, formatPath)
 		if err != nil {
-			return nil, errors.Wrapf(err, "error creating handler at path %s for CPU %d", formatPath, cpu)
+			return nil, fmt.Errorf("error creating handler at path %s for CPU %d: %w", formatPath, cpu, err)
 		}
 		handlers[cpu] = handler
 
@@ -207,7 +207,7 @@ func (m *MetricSet) updatePower() map[int]map[rapl.RAPLDomain]energyUsage {
 func getMSRCPUs(hostfs resolve.Resolver) ([]int, error) {
 	CPUs, err := topoPkgCPUMap(hostfs)
 	if err != nil {
-		return nil, errors.Wrap(err, "error fetching CPU topology")
+		return nil, fmt.Errorf("error fetching CPU topology: %w", err)
 	}
 	coreList := []int{}
 	for _, cores := range CPUs {
@@ -244,16 +244,16 @@ func topoPkgCPUMap(hostfs resolve.Resolver) (map[int][]int, error) {
 			fullPkg := hostfs.ResolveHostFS(filepath.Join(sysdir, file.Name(), "/topology/physical_package_id"))
 			dat, err := ioutil.ReadFile(fullPkg)
 			if err != nil {
-				return nil, errors.Wrapf(err, "error reading file %s", fullPkg)
+				return nil, fmt.Errorf("error reading file %s: %w", fullPkg, err)
 			}
 			phys, err := strconv.ParseInt(strings.TrimSpace(string(dat)), 10, 64)
 			if err != nil {
-				return nil, errors.Wrapf(err, "error parsing value from %s", fullPkg)
+				return nil, fmt.Errorf("error parsing value from %s: %w", fullPkg, err)
 			}
 			var cpuCore int
 			_, err = fmt.Sscanf(file.Name(), "cpu%d", &cpuCore)
 			if err != nil {
-				return nil, errors.Wrapf(err, "error fetching CPU core value from string %s", file.Name())
+				return nil, fmt.Errorf("error fetching CPU core value from string %s: %w", file.Name(), err)
 			}
 			pkgList, ok := cpuMap[int(phys)]
 			if !ok {
diff --git a/metricbeat/module/linux/util.go b/metricbeat/module/linux/util.go
index 87b9bcd0512..def4603c816 100644
--- a/metricbeat/module/linux/util.go
+++ b/metricbeat/module/linux/util.go
@@ -18,11 +18,10 @@
 package linux
 
 import (
+	"fmt"
 	"io/ioutil"
 	"strconv"
 	"strings"
-
-	"github.com/pkg/errors"
 )
 
 // ReadIntFromFile reads a single int value from a path and returns an int64.
@@ -31,14 +30,14 @@ func ReadIntFromFile(path string, base int) (int64, error) {
 
 	raw, err := ioutil.ReadFile(path)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error reading file %s", path)
+		return 0, fmt.Errorf("error reading file %s: %w", path, err)
 	}
 
 	clean := strings.TrimSpace(string(raw))
 
 	intval, err := strconv.ParseInt(clean, 10, 64)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error converting string: %s", clean)
+		return 0, fmt.Errorf("error converting string: %s: %w", clean, err)
 	}
 
 	return intval, nil
diff --git a/metricbeat/module/logstash/logstash.go b/metricbeat/module/logstash/logstash.go
index 8623bcd9a80..6e796633612 100644
--- a/metricbeat/module/logstash/logstash.go
+++ b/metricbeat/module/logstash/logstash.go
@@ -22,8 +22,6 @@ import (
 	"fmt"
 	"net/url"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/helper/elastic"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -109,7 +107,7 @@ func NewMetricSet(base mb.BaseMetricSet) (*MetricSet, error) {
 func GetPipelines(m *MetricSet) ([]PipelineState, string, error) {
 	content, err := fetchPath(m.HTTP, "_node/pipelines", "graph=true")
 	if err != nil {
-		return nil, "", errors.Wrap(err, "could not fetch node pipelines")
+		return nil, "", fmt.Errorf("could not fetch node pipelines: %w", err)
 	}
 
 	pipelinesResponse := struct {
@@ -121,7 +119,7 @@ func GetPipelines(m *MetricSet) ([]PipelineState, string, error) {
 
 	err = json.Unmarshal(content, &pipelinesResponse)
 	if err != nil {
-		return nil, "", errors.Wrap(err, "could not parse node pipelines response")
+		return nil, "", fmt.Errorf("could not parse node pipelines response: %w", err)
 	}
 
 	var pipelines []PipelineState
diff --git a/metricbeat/module/logstash/node/data.go b/metricbeat/module/logstash/node/data.go
index 0ccc42ef7df..49c17b73275 100644
--- a/metricbeat/module/logstash/node/data.go
+++ b/metricbeat/module/logstash/node/data.go
@@ -19,8 +19,7 @@ package node
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common"
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
@@ -86,7 +85,7 @@ func eventMapping(r mb.ReporterV2, content []byte, pipelines []logstash.Pipeline
 	var data map[string]interface{}
 	err := json.Unmarshal(content, &data)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing Logstash Node API response")
+		return fmt.Errorf("failure parsing Logstash Node API response: %w", err)
 	}
 
 	pipelines = getUserDefinedPipelines(pipelines)
@@ -96,7 +95,7 @@ func eventMapping(r mb.ReporterV2, content []byte, pipelines []logstash.Pipeline
 		for _, pipeline := range pipelines {
 			fields, err := schema.Apply(data)
 			if err != nil {
-				return errors.Wrap(err, "failure applying node schema")
+				return fmt.Errorf("failure applying node schema: %w", err)
 			}
 			removeClusterUUIDsFromPipeline(pipeline)
 
diff --git a/metricbeat/module/memcached/stats/stats.go b/metricbeat/module/memcached/stats/stats.go
index 6e9ebb66d3f..890a8c701f7 100644
--- a/metricbeat/module/memcached/stats/stats.go
+++ b/metricbeat/module/memcached/stats/stats.go
@@ -19,12 +19,11 @@ package stats
 
 import (
 	"bufio"
+	"fmt"
 	"net"
 	"net/url"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 )
@@ -54,18 +53,18 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	network, address, err := getNetworkAndAddress(m.HostData())
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 
 	conn, err := net.DialTimeout(network, address, m.Module().Config().Timeout)
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	defer conn.Close()
 
 	_, err = conn.Write([]byte("stats\n"))
 	if err != nil {
-		return errors.Wrap(err, "error in connection")
+		return fmt.Errorf("error in connection: %w", err)
 	}
 
 	scanner := bufio.NewScanner(conn)
@@ -95,7 +94,7 @@ func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 func getNetworkAndAddress(hostData mb.HostData) (network string, address string, err error) {
 	u, err := url.Parse(hostData.URI)
 	if err != nil {
-		err = errors.Wrap(err, "invalid URL")
+		err = fmt.Errorf("invalid URL: %w", err)
 		return
 	}
 
diff --git a/metricbeat/module/munin/munin.go b/metricbeat/module/munin/munin.go
index fe2b981d6ba..4438f510d4c 100644
--- a/metricbeat/module/munin/munin.go
+++ b/metricbeat/module/munin/munin.go
@@ -19,6 +19,8 @@ package munin
 
 import (
 	"bufio"
+	"errors"
+	"fmt"
 	"io"
 	"net"
 	"regexp"
@@ -26,8 +28,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
@@ -88,7 +88,7 @@ func (n *Node) List() ([]string, error) {
 func (n *Node) Fetch(plugin string, sanitize bool) (mapstr.M, error) {
 	_, err := io.WriteString(n.writer, "fetch "+plugin+"\n")
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to fetch metrics for plugin '%s'", plugin)
+		return nil, fmt.Errorf("failed to fetch metrics for plugin '%s': %w", plugin, err)
 	}
 
 	event := mapstr.M{}
diff --git a/metricbeat/module/nats/connection/connection.go b/metricbeat/module/nats/connection/connection.go
index b491d35ef30..0fc8cff2b60 100644
--- a/metricbeat/module/nats/connection/connection.go
+++ b/metricbeat/module/nats/connection/connection.go
@@ -18,7 +18,7 @@
 package connection
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -84,11 +84,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventsMapping(r, content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 	return nil
 }
diff --git a/metricbeat/module/nats/connection/data.go b/metricbeat/module/nats/connection/data.go
index cc2b26dfbb5..c385ddcdc1d 100644
--- a/metricbeat/module/nats/connection/data.go
+++ b/metricbeat/module/nats/connection/data.go
@@ -19,10 +19,9 @@ package connection
 
 import (
 	"encoding/json"
+	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -63,26 +62,26 @@ type Connections struct {
 func eventMapping(content map[string]interface{}, fieldsSchema s.Schema) (mb.Event, error) {
 	fields, err := fieldsSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying connection schema")
+		return mb.Event{}, fmt.Errorf("error applying connection schema: %w", err)
 	}
 
 	err = util.UpdateDuration(fields, "uptime")
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "failure updating uptime key")
+		return mb.Event{}, fmt.Errorf("failure updating uptime key: %w", err)
 	}
 
 	err = util.UpdateDuration(fields, "idle_time")
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "failure updating idle_time key")
+		return mb.Event{}, fmt.Errorf("failure updating idle_time key: %w", err)
 	}
 
 	moduleFields, err := moduleSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying module schema")
+		return mb.Event{}, fmt.Errorf("error applying module schema: %w", err)
 	}
 
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "failure parsing server timestamp")
+		return mb.Event{}, fmt.Errorf("failure parsing server timestamp: %w", err)
 	}
 	event := mb.Event{
 		MetricSetFields: fields,
@@ -96,7 +95,7 @@ func eventsMapping(r mb.ReporterV2, content []byte) error {
 	var err error
 	connections := Connections{}
 	if err = json.Unmarshal(content, &connections); err != nil {
-		return errors.Wrap(err, "failure parsing NATS connections API response")
+		return fmt.Errorf("failure parsing NATS connections API response: %w", err)
 	}
 
 	for _, con := range connections.Connections {
@@ -104,7 +103,7 @@ func eventsMapping(r mb.ReporterV2, content []byte) error {
 		con["server_id"] = connections.ServerID
 		evt, err = eventMapping(con, connectionsSchema)
 		if err != nil {
-			r.Error(errors.Wrap(err, "error mapping connection event"))
+			r.Error(fmt.Errorf("error mapping connection event: %w", err))
 			continue
 		}
 		evt.Timestamp = connections.Now
diff --git a/metricbeat/module/nats/connections/connections.go b/metricbeat/module/nats/connections/connections.go
index 8fcfb652e9f..3fb41cc5e2f 100644
--- a/metricbeat/module/nats/connections/connections.go
+++ b/metricbeat/module/nats/connections/connections.go
@@ -18,7 +18,7 @@
 package connections
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -85,11 +85,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventMapping(r, content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 	return nil
 }
diff --git a/metricbeat/module/nats/connections/data.go b/metricbeat/module/nats/connections/data.go
index 241f46f77d2..200bb32c8ad 100644
--- a/metricbeat/module/nats/connections/data.go
+++ b/metricbeat/module/nats/connections/data.go
@@ -19,8 +19,7 @@ package connections
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -45,21 +44,21 @@ func eventMapping(r mb.ReporterV2, content []byte) error {
 
 	err := json.Unmarshal(content, &inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing NATS connections API response")
+		return fmt.Errorf("failure parsing NATS connections API response: %w", err)
 	}
 	metricSetFields, err := connectionsSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying connections schema")
+		return fmt.Errorf("failure applying connections schema: %w", err)
 
 	}
 
 	moduleFields, err := moduleSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying module schema")
+		return fmt.Errorf("failure applying module schema: %w", err)
 	}
 	timestamp, err := util.GetNatsTimestamp(moduleFields)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing server timestamp")
+		return fmt.Errorf("failure parsing server timestamp: %w", err)
 	}
 	event := mb.Event{
 		MetricSetFields: metricSetFields,
diff --git a/metricbeat/module/nats/route/data.go b/metricbeat/module/nats/route/data.go
index 932933f9d9d..853c7a9cb83 100644
--- a/metricbeat/module/nats/route/data.go
+++ b/metricbeat/module/nats/route/data.go
@@ -19,10 +19,9 @@ package route
 
 import (
 	"encoding/json"
+	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -62,16 +61,16 @@ type Routes struct {
 func eventMapping(content map[string]interface{}, fieldsSchema s.Schema) (mb.Event, error) {
 	fields, err := fieldsSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying routes schema")
+		return mb.Event{}, fmt.Errorf("error applying routes schema: %w", err)
 	}
 
 	moduleFields, err := moduleSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying module schema")
+		return mb.Event{}, fmt.Errorf("error applying module schema: %w", err)
 	}
 
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "failure parsing server timestamp")
+		return mb.Event{}, fmt.Errorf("failure parsing server timestamp: %w", err)
 	}
 	event := mb.Event{
 		MetricSetFields: fields,
@@ -85,7 +84,7 @@ func eventsMapping(r mb.ReporterV2, content []byte) error {
 	var err error
 	connections := Routes{}
 	if err = json.Unmarshal(content, &connections); err != nil {
-		return errors.Wrap(err, "failure parsing NATS connections API response")
+		return fmt.Errorf("failure parsing NATS connections API response: %w", err)
 	}
 
 	for _, con := range connections.Routes {
@@ -93,7 +92,7 @@ func eventsMapping(r mb.ReporterV2, content []byte) error {
 		con["server_id"] = connections.ServerID
 		evt, err = eventMapping(con, routesSchema)
 		if err != nil {
-			r.Error(errors.Wrap(err, "error mapping connection event"))
+			r.Error(fmt.Errorf("error mapping connection event: %w", err))
 			continue
 		}
 		evt.Timestamp = connections.Now
diff --git a/metricbeat/module/nats/route/route.go b/metricbeat/module/nats/route/route.go
index bf5814157f2..a2c1cb20f3d 100644
--- a/metricbeat/module/nats/route/route.go
+++ b/metricbeat/module/nats/route/route.go
@@ -18,7 +18,7 @@
 package route
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -84,11 +84,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventsMapping(r, content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/metricbeat/module/nats/routes/data.go b/metricbeat/module/nats/routes/data.go
index 02eb686e709..78c7cb10c30 100644
--- a/metricbeat/module/nats/routes/data.go
+++ b/metricbeat/module/nats/routes/data.go
@@ -19,8 +19,7 @@ package routes
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -45,20 +44,20 @@ func eventMapping(r mb.ReporterV2, content []byte) error {
 
 	err := json.Unmarshal(content, &inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing Nats routes API response")
+		return fmt.Errorf("failure parsing Nats routes API response: %w", err)
 	}
 	metricSetFields, err := routesSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying routes schema")
+		return fmt.Errorf("failure applying routes schema: %w", err)
 	}
 
 	moduleFields, err := moduleSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying module schema")
+		return fmt.Errorf("failure applying module schema: %w", err)
 	}
 	timestamp, err := util.GetNatsTimestamp(moduleFields)
 	if err != nil {
-		errors.Wrap(err, "failure parsing server timestamp")
+		return fmt.Errorf("failure parsing server timestamp: %w", err)
 	}
 	event := mb.Event{
 		MetricSetFields: metricSetFields,
diff --git a/metricbeat/module/nats/routes/routes.go b/metricbeat/module/nats/routes/routes.go
index 88eeebab41a..b3db4c4f7f7 100644
--- a/metricbeat/module/nats/routes/routes.go
+++ b/metricbeat/module/nats/routes/routes.go
@@ -18,7 +18,7 @@
 package routes
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -85,11 +85,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventMapping(r, content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/metricbeat/module/nats/stats/data.go b/metricbeat/module/nats/stats/data.go
index 7bc72177a54..c7f2ca719ef 100644
--- a/metricbeat/module/nats/stats/data.go
+++ b/metricbeat/module/nats/stats/data.go
@@ -19,8 +19,7 @@ package stats
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -71,30 +70,29 @@ func eventMapping(r mb.ReporterV2, content []byte) error {
 
 	err := json.Unmarshal(content, &inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing Nats stats API response")
+		return fmt.Errorf("failure parsing Nats stats API response: %w", err)
 	}
 	metricsetMetrics, err = statsSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying stats schema")
+		return fmt.Errorf("failure applying stats schema: %w", err)
 	}
 
 	err = util.UpdateDuration(metricsetMetrics, "uptime")
 	if err != nil {
-		return errors.Wrap(err, "failure updating uptime key")
+		return fmt.Errorf("failure updating uptime key: %w", err)
 	}
 
 	d, err := metricsetMetrics.GetValue("http_req_stats")
 	if err != nil {
-		return errors.Wrap(err, "failure retrieving http_req_stats key")
+		return fmt.Errorf("failure retrieving http_req_stats key: %w", err)
 	}
 	httpStats, ok := d.(mapstr.M)
 	if !ok {
-		return errors.Wrap(err, "failure casting http_req_stats to common.Mapstr")
-
+		return fmt.Errorf("failure casting http_req_stats to common.Mapstr")
 	}
 	err = metricsetMetrics.Delete("http_req_stats")
 	if err != nil {
-		return errors.Wrap(err, "failure deleting http_req_stats key")
+		return fmt.Errorf("failure deleting http_req_stats key: %w", err)
 
 	}
 	metricsetMetrics["http"] = mapstr.M{
@@ -110,23 +108,23 @@ func eventMapping(r mb.ReporterV2, content []byte) error {
 	}
 	cpu, err := metricsetMetrics.GetValue("cpu")
 	if err != nil {
-		return errors.Wrap(err, "failure retrieving cpu key")
+		return fmt.Errorf("failure retrieving cpu key: %w", err)
 	}
 	cpuUtil, ok := cpu.(float64)
 	if !ok {
-		return errors.Wrap(err, "failure casting cpu to float64")
+		return fmt.Errorf("failure casting cpu to float64")
 	}
 	_, err = metricsetMetrics.Put("cpu", cpuUtil/100.0)
 	if err != nil {
-		return errors.Wrap(err, "failure updating cpu key")
+		return fmt.Errorf("failure updating cpu key: %w", err)
 	}
 	moduleMetrics, err := moduleSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying module schema")
+		return fmt.Errorf("failure applying module schema: %w", err)
 	}
 	timestamp, err := util.GetNatsTimestamp(moduleMetrics)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing server timestamp")
+		return fmt.Errorf("failure parsing server timestamp: %w", err)
 	}
 	evt := mb.Event{
 		MetricSetFields: metricsetMetrics,
diff --git a/metricbeat/module/nats/stats/stats.go b/metricbeat/module/nats/stats/stats.go
index fe1cfbdd975..5d5d69ff584 100644
--- a/metricbeat/module/nats/stats/stats.go
+++ b/metricbeat/module/nats/stats/stats.go
@@ -18,7 +18,7 @@
 package stats
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -85,11 +85,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventMapping(r, content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/metricbeat/module/nats/subscriptions/data.go b/metricbeat/module/nats/subscriptions/data.go
index a92bcae4b14..e06a39e913b 100644
--- a/metricbeat/module/nats/subscriptions/data.go
+++ b/metricbeat/module/nats/subscriptions/data.go
@@ -19,8 +19,7 @@ package subscriptions
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -50,12 +49,12 @@ func eventMapping(r mb.ReporterV2, content []byte) error {
 
 	err := json.Unmarshal(content, &inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure parsing Nats subscriptions API response")
+		return fmt.Errorf("failure parsing Nats subscriptions API response: %w", err)
 
 	}
 	event.MetricSetFields, err = subscriptionsSchema.Apply(inInterface)
 	if err != nil {
-		return errors.Wrap(err, "failure applying subscriptions schema")
+		return fmt.Errorf("failure applying subscriptions schema: %w", err)
 	}
 
 	r.Event(event)
diff --git a/metricbeat/module/nats/subscriptions/subscriptions.go b/metricbeat/module/nats/subscriptions/subscriptions.go
index e9183f214c7..903606a3721 100644
--- a/metricbeat/module/nats/subscriptions/subscriptions.go
+++ b/metricbeat/module/nats/subscriptions/subscriptions.go
@@ -18,7 +18,7 @@
 package subscriptions
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -85,11 +85,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventMapping(r, content)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/metricbeat/module/nats/util/util.go b/metricbeat/module/nats/util/util.go
index 1decbf0bb9f..ada2e12ef01 100644
--- a/metricbeat/module/nats/util/util.go
+++ b/metricbeat/module/nats/util/util.go
@@ -23,8 +23,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
 
@@ -39,7 +37,7 @@ func convertUptimeToSeconds(uptime string) (seconds int64, err error) {
 		uptime = split[1]
 		years, err = strconv.ParseInt(split[0], 10, 64)
 		if err != nil {
-			err = errors.Wrap(err, "invalid years format in json data")
+			err = fmt.Errorf("invalid years format in json data: %w", err)
 			return
 		}
 		seconds += years * 31536000
@@ -50,7 +48,7 @@ func convertUptimeToSeconds(uptime string) (seconds int64, err error) {
 		uptime = split[1]
 		days, err = strconv.ParseInt(split[0], 10, 64)
 		if err != nil {
-			err = errors.Wrap(err, "invalid days format in json data")
+			err = fmt.Errorf("invalid days format in json data: %w", err)
 			return
 		}
 		seconds += days * 86400
@@ -61,7 +59,7 @@ func convertUptimeToSeconds(uptime string) (seconds int64, err error) {
 		uptime = split[1]
 		hours, err = strconv.ParseInt(split[0], 10, 64)
 		if err != nil {
-			err = errors.Wrap(err, "invalid hours format in json data")
+			err = fmt.Errorf("invalid hours format in json data: %w", err)
 			return
 		}
 		seconds += hours * 3600
@@ -72,7 +70,7 @@ func convertUptimeToSeconds(uptime string) (seconds int64, err error) {
 		uptime = split[1]
 		minutes, err = strconv.ParseInt(split[0], 10, 64)
 		if err != nil {
-			err = errors.Wrap(err, "invalid minutes format in json data")
+			err = fmt.Errorf("invalid minutes format in json data: %w", err)
 			return
 		}
 		seconds += minutes * 60
@@ -83,7 +81,7 @@ func convertUptimeToSeconds(uptime string) (seconds int64, err error) {
 		uptime = split[1]
 		secs, err = strconv.ParseInt(split[0], 10, 64)
 		if err != nil {
-			err = errors.Wrap(err, "invalid seconds format in json data")
+			err = fmt.Errorf("invalid seconds format in json data: %w", err)
 			return
 		}
 		seconds += secs
@@ -99,11 +97,11 @@ func UpdateDuration(event mapstr.M, key string) error {
 	}
 	itemConverted, err := convertUptimeToSeconds(item.(string))
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("failure converting %v key from string to integer", key))
+		return fmt.Errorf(fmt.Sprintf("failure converting %v key from string to integer", key)+": %w", err)
 	}
 	_, err = event.Put(key, itemConverted)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("failure updating %v key", key))
+		return fmt.Errorf(fmt.Sprintf("failure updating %v key", key)+": %w", err)
 	}
 	return nil
 }
diff --git a/metricbeat/module/nginx/stubstatus/stubstatus.go b/metricbeat/module/nginx/stubstatus/stubstatus.go
index 7df0acf5336..5c28a82f464 100644
--- a/metricbeat/module/nginx/stubstatus/stubstatus.go
+++ b/metricbeat/module/nginx/stubstatus/stubstatus.go
@@ -19,7 +19,7 @@
 package stubstatus
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -78,7 +78,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	scanner, err := m.http.FetchScanner()
 	if err != nil {
-		return errors.Wrap(err, "error fetching status")
+		return fmt.Errorf("error fetching status: %w", err)
 	}
 	event, _ := eventMapping(scanner, m)
 	reporter.Event(mb.Event{MetricSetFields: event})
diff --git a/metricbeat/module/php_fpm/pool/pool.go b/metricbeat/module/php_fpm/pool/pool.go
index ec15fb46915..cc322529863 100644
--- a/metricbeat/module/php_fpm/pool/pool.go
+++ b/metricbeat/module/php_fpm/pool/pool.go
@@ -19,8 +19,7 @@ package pool
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -58,16 +57,16 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	content, err := m.HTTP.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in http fetch")
+		return fmt.Errorf("error in http fetch: %w", err)
 	}
 	var stats map[string]interface{}
 	err = json.Unmarshal(content, &stats)
 	if err != nil {
-		return errors.Wrap(err, "error unmarshalling json")
+		return fmt.Errorf("error unmarshalling json: %w", err)
 	}
 	event, err := schema.Apply(stats)
 	if err != nil {
-		return errors.Wrap(err, "error in event mapping")
+		return fmt.Errorf("error in event mapping: %w", err)
 	}
 	reporter.Event(mb.Event{
 		MetricSetFields: event,
diff --git a/metricbeat/module/postgresql/activity/activity.go b/metricbeat/module/postgresql/activity/activity.go
index ac2748cd582..b97830c8edc 100644
--- a/metricbeat/module/postgresql/activity/activity.go
+++ b/metricbeat/module/postgresql/activity/activity.go
@@ -19,8 +19,7 @@ package activity
 
 import (
 	"context"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/module/postgresql"
@@ -60,7 +59,7 @@ func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 
 	results, err := m.QueryStats(ctx, "SELECT * FROM pg_stat_activity")
 	if err != nil {
-		return errors.Wrap(err, "error in QueryStats")
+		return fmt.Errorf("error in QueryStats: %w", err)
 	}
 
 	for _, result := range results {
diff --git a/metricbeat/module/postgresql/database/database.go b/metricbeat/module/postgresql/database/database.go
index 0b23a25d27b..48fc032ad81 100644
--- a/metricbeat/module/postgresql/database/database.go
+++ b/metricbeat/module/postgresql/database/database.go
@@ -19,8 +19,7 @@ package database
 
 import (
 	"context"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/module/postgresql"
@@ -59,7 +58,7 @@ func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	ctx := context.Background()
 	results, err := m.QueryStats(ctx, "SELECT * FROM pg_stat_database")
 	if err != nil {
-		return errors.Wrap(err, "error in QueryStats")
+		return fmt.Errorf("error in QueryStats: %w", err)
 	}
 
 	for _, result := range results {
diff --git a/metricbeat/module/postgresql/metricset.go b/metricbeat/module/postgresql/metricset.go
index ca0a4e4a4d0..3ebcff4dafe 100644
--- a/metricbeat/module/postgresql/metricset.go
+++ b/metricbeat/module/postgresql/metricset.go
@@ -20,8 +20,7 @@ package postgresql
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -46,7 +45,7 @@ func (ms *MetricSet) DB(ctx context.Context) (*sql.Conn, error) {
 	if ms.db == nil {
 		db, err := sql.Open("postgres", ms.HostData().URI)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to open connection")
+			return nil, fmt.Errorf("failed to open connection: %w", err)
 		}
 		ms.db = db
 	}
@@ -57,18 +56,18 @@ func (ms *MetricSet) DB(ctx context.Context) (*sql.Conn, error) {
 func (ms *MetricSet) QueryStats(ctx context.Context, query string) ([]map[string]interface{}, error) {
 	db, err := ms.DB(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain a connection with the database")
+		return nil, fmt.Errorf("failed to obtain a connection with the database: %w", err)
 	}
 	defer db.Close()
 
 	rows, err := db.QueryContext(ctx, query)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to query database")
+		return nil, fmt.Errorf("failed to query database: %w", err)
 	}
 
 	columns, err := rows.Columns()
 	if err != nil {
-		return nil, errors.Wrap(err, "scanning columns")
+		return nil, fmt.Errorf("scanning columns: %w", err)
 	}
 	vals := make([][]byte, len(columns))
 	valPointers := make([]interface{}, len(columns))
@@ -81,7 +80,7 @@ func (ms *MetricSet) QueryStats(ctx context.Context, query string) ([]map[string
 	for rows.Next() {
 		err = rows.Scan(valPointers...)
 		if err != nil {
-			return nil, errors.Wrap(err, "scanning row")
+			return nil, fmt.Errorf("scanning row: %w", err)
 		}
 
 		result := map[string]interface{}{}
@@ -100,5 +99,9 @@ func (ms *MetricSet) Close() error {
 	if ms.db == nil {
 		return nil
 	}
-	return errors.Wrap(ms.db.Close(), "failed to close connection")
+
+	if err := ms.db.Close(); err != nil {
+		return fmt.Errorf("failed to close connection: %w", err)
+	}
+	return nil
 }
diff --git a/metricbeat/module/redis/info/info.go b/metricbeat/module/redis/info/info.go
index f292e10e852..bef98dd9f1a 100644
--- a/metricbeat/module/redis/info/info.go
+++ b/metricbeat/module/redis/info/info.go
@@ -18,10 +18,9 @@
 package info
 
 import (
+	"fmt"
 	"strconv"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 	"github.com/elastic/beats/v7/metricbeat/module/redis"
@@ -45,7 +44,7 @@ type MetricSet struct {
 func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 	ms, err := redis.NewMetricSet(base)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create 'info' metricset")
+		return nil, fmt.Errorf("failed to create 'info' metricset: %w", err)
 	}
 	return &MetricSet{ms}, nil
 }
@@ -55,14 +54,14 @@ func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	conn := m.Connection()
 	defer func() {
 		if err := conn.Close(); err != nil {
-			m.Logger().Debug(errors.Wrapf(err, "failed to release connection"))
+			m.Logger().Debug(fmt.Errorf("failed to release connection: %w", err))
 		}
 	}()
 
 	// Fetch all INFO.
 	info, err := redis.FetchRedisInfo("all", conn)
 	if err != nil {
-		return errors.Wrap(err, "failed to fetch redis info")
+		return fmt.Errorf("failed to fetch redis info: %w", err)
 	}
 
 	// In 5.0 some fields are renamed, maintain both names, old ones will be deprecated
@@ -81,7 +80,7 @@ func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 
 	slowLogLength, err := redis.FetchSlowLogLength(conn)
 	if err != nil {
-		return errors.Wrap(err, "failed to fetch slow log length")
+		return fmt.Errorf("failed to fetch slow log length: %w", err)
 
 	}
 	info["slowlog_len"] = strconv.FormatInt(slowLogLength, 10)
diff --git a/metricbeat/module/redis/keyspace/keyspace.go b/metricbeat/module/redis/keyspace/keyspace.go
index a9710fa67f9..afa6a485fc3 100644
--- a/metricbeat/module/redis/keyspace/keyspace.go
+++ b/metricbeat/module/redis/keyspace/keyspace.go
@@ -18,7 +18,7 @@
 package keyspace
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
@@ -43,7 +43,7 @@ type MetricSet struct {
 func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 	ms, err := redis.NewMetricSet(base)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create 'keyspace' metricset")
+		return nil, fmt.Errorf("failed to create 'keyspace' metricset: %w", err)
 	}
 	return &MetricSet{ms}, nil
 }
@@ -53,14 +53,14 @@ func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	conn := m.Connection()
 	defer func() {
 		if err := conn.Close(); err != nil {
-			m.Logger().Debug(errors.Wrapf(err, "failed to release connection"))
+			m.Logger().Debug(fmt.Errorf("failed to release connection: %w", err))
 		}
 	}()
 
 	// Fetch default INFO.
 	info, err := redis.FetchRedisInfo("keyspace", conn)
 	if err != nil {
-		return errors.Wrap(err, "Failed to fetch redis info for keyspaces")
+		return fmt.Errorf("Failed to fetch redis info for keyspaces: %w", err)
 	}
 
 	m.Logger().Debugf("Redis INFO from %s: %+v", m.Host(), info)
diff --git a/metricbeat/module/system/core/config.go b/metricbeat/module/system/core/config.go
index 09b1b25f7ed..8ac1d2f9575 100644
--- a/metricbeat/module/system/core/config.go
+++ b/metricbeat/module/system/core/config.go
@@ -18,10 +18,10 @@
 package core
 
 import (
+	"errors"
+	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	metrics "github.com/elastic/elastic-agent-system-metrics/metric/cpu"
 )
@@ -56,7 +56,7 @@ func (c Config) Validate() (metrics.MetricOpts, error) {
 		case ticks:
 			opts.Ticks = true
 		default:
-			return opts, errors.Errorf("invalid core.metrics value '%v' (valid "+
+			return opts, fmt.Errorf("invalid core.metrics value '%v' (valid "+
 				"options are %v and %v)", metric, percentages, ticks)
 		}
 	}
diff --git a/metricbeat/module/system/cpu/config.go b/metricbeat/module/system/cpu/config.go
index 9533bf7b296..ef9d78fe0ce 100644
--- a/metricbeat/module/system/cpu/config.go
+++ b/metricbeat/module/system/cpu/config.go
@@ -18,10 +18,10 @@
 package cpu
 
 import (
+	"errors"
+	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	metrics "github.com/elastic/elastic-agent-system-metrics/metric/cpu"
 )
@@ -59,7 +59,7 @@ func (c Config) Validate() (metrics.MetricOpts, error) {
 		case ticks:
 			opts.Ticks = true
 		default:
-			return opts, errors.Errorf("invalid cpu.metrics value '%v' (valid "+
+			return opts, fmt.Errorf("invalid cpu.metrics value '%v' (valid "+
 				"options are %v, %v, and %v)", metric, percentages,
 				normalizedPercentages, ticks)
 		}
diff --git a/metricbeat/module/system/entropy/entropy.go b/metricbeat/module/system/entropy/entropy.go
index 5bc83210eab..a9ea007af69 100644
--- a/metricbeat/module/system/entropy/entropy.go
+++ b/metricbeat/module/system/entropy/entropy.go
@@ -20,12 +20,11 @@
 package entropy
 
 import (
+	"fmt"
 	"io/ioutil"
 	"strconv"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -68,11 +67,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	entropy, err := getEntropyData(m.mod.ResolveHostFS("/proc/sys/kernel/random/entropy_avail"))
 	if err != nil {
-		return errors.Wrap(err, "error getting entropy")
+		return fmt.Errorf("error getting entropy: %w", err)
 	}
 	poolsize, err := getEntropyData(m.mod.ResolveHostFS("/proc/sys/kernel/random/poolsize"))
 	if err != nil {
-		return errors.Wrap(err, "error getting poolsize")
+		return fmt.Errorf("error getting poolsize: %w", err)
 	}
 	report.Event(mb.Event{
 		MetricSetFields: mapstr.M{
@@ -88,12 +87,12 @@ func getEntropyData(path string) (int, error) {
 	//This will be a number in the range 0 to 4096.
 	raw, err := ioutil.ReadFile(path)
 	if err != nil {
-		return 0, errors.Wrap(err, "error reading from random")
+		return 0, fmt.Errorf("error reading from random: %w", err)
 	}
 
 	intval, err := strconv.ParseInt(strings.TrimSpace(string(raw)), 10, 64)
 	if err != nil {
-		return 0, errors.Wrap(err, "error parsing from random")
+		return 0, fmt.Errorf("error parsing from random: %w", err)
 	}
 
 	return int(intval), nil
diff --git a/metricbeat/module/system/load/load.go b/metricbeat/module/system/load/load.go
index c674a5dc819..a28571124f1 100644
--- a/metricbeat/module/system/load/load.go
+++ b/metricbeat/module/system/load/load.go
@@ -20,7 +20,7 @@
 package load
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
@@ -52,7 +52,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	load, err := cpu.Load()
 	if err != nil {
-		return errors.Wrap(err, "failed to get CPU load values")
+		return fmt.Errorf("failed to get CPU load values: %w", err)
 	}
 
 	avgs := load.Averages()
diff --git a/metricbeat/module/system/network/network.go b/metricbeat/module/system/network/network.go
index 1e153d082a5..3ef0b1ca795 100644
--- a/metricbeat/module/system/network/network.go
+++ b/metricbeat/module/system/network/network.go
@@ -20,6 +20,7 @@
 package network
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -27,7 +28,6 @@ import (
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 
-	"github.com/pkg/errors"
 	"github.com/shirou/gopsutil/v3/net"
 )
 
@@ -86,7 +86,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	stats, err := net.IOCounters(true)
 	if err != nil {
-		return errors.Wrap(err, "network io counters")
+		return fmt.Errorf("network io counters: %w", err)
 	}
 
 	var networkInBytes, networkOutBytes, networkInPackets, networkOutPackets uint64
diff --git a/metricbeat/module/system/network_summary/network_summary.go b/metricbeat/module/system/network_summary/network_summary.go
index 92a48d23b61..757ed56b267 100644
--- a/metricbeat/module/system/network_summary/network_summary.go
+++ b/metricbeat/module/system/network_summary/network_summary.go
@@ -18,7 +18,8 @@
 package network_summary
 
 import (
-	"github.com/pkg/errors"
+	"errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -64,7 +65,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	counterInfo, err := fetchNetStats()
 	if err != nil {
-		return errors.Wrap(err, "Error fetching stats")
+		return fmt.Errorf("Error fetching stats: %w", err)
 	}
 	if counterInfo == nil {
 		return errors.New("NetworkCounters not available on this platform")
@@ -81,13 +82,13 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 func fetchNetStats() (*sysinfotypes.NetworkCountersInfo, error) {
 	h, err := sysinfo.Host()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to read self process information")
+		return nil, fmt.Errorf("failed to read self process information: %w", err)
 	}
 
 	if vmstatHandle, ok := h.(sysinfotypes.NetworkCounters); ok {
 		info, err := vmstatHandle.NetworkCounters()
 		if err != nil {
-			return nil, errors.Wrap(err, "error getting network counters")
+			return nil, fmt.Errorf("error getting network counters: %w", err)
 		}
 		return info, nil
 	}
diff --git a/metricbeat/module/system/process/process.go b/metricbeat/module/system/process/process.go
index 6256f90f742..2274f1846d6 100644
--- a/metricbeat/module/system/process/process.go
+++ b/metricbeat/module/system/process/process.go
@@ -20,11 +20,10 @@
 package process
 
 import (
+	"fmt"
 	"os"
 	"runtime"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -104,7 +103,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	procs, roots, err := m.stats.Get()
 	if err != nil {
-		return errors.Wrap(err, "process stats")
+		return fmt.Errorf("process stats: %w", err)
 	}
 
 	for evtI := range procs {
diff --git a/metricbeat/module/system/raid/blockinfo/getdev.go b/metricbeat/module/system/raid/blockinfo/getdev.go
index bb2bae080ee..02527c80636 100644
--- a/metricbeat/module/system/raid/blockinfo/getdev.go
+++ b/metricbeat/module/system/raid/blockinfo/getdev.go
@@ -22,15 +22,13 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-
-	"github.com/pkg/errors"
 )
 
 // ListAll lists all the multi-disk devices in a RAID array
 func ListAll(path string) ([]MDDevice, error) {
 	dir, err := ioutil.ReadDir(path)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not read directory")
+		return nil, fmt.Errorf("could not read directory: %w", err)
 	}
 	var mds []MDDevice
 	for _, item := range dir {
@@ -40,7 +38,7 @@ func ListAll(path string) ([]MDDevice, error) {
 		}
 		dev, err := getMDDevice(testpath)
 		if err != nil {
-			return nil, errors.Wrap(err, "could not get device info")
+			return nil, fmt.Errorf("could not get device info: %w", err)
 		}
 		mds = append(mds, dev)
 	}
@@ -56,7 +54,7 @@ func ListAll(path string) ([]MDDevice, error) {
 func getMDDevice(path string) (MDDevice, error) {
 	_, err := os.Stat(path)
 	if err != nil {
-		return MDDevice{}, errors.Wrap(err, "path does not exist")
+		return MDDevice{}, fmt.Errorf("path does not exist: %w", err)
 	}
 
 	//This is the best heuristic I've found so far for identifying an md device.
diff --git a/metricbeat/module/system/raid/blockinfo/parser.go b/metricbeat/module/system/raid/blockinfo/parser.go
index 7c517b6f534..3763ed28ab6 100644
--- a/metricbeat/module/system/raid/blockinfo/parser.go
+++ b/metricbeat/module/system/raid/blockinfo/parser.go
@@ -24,8 +24,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
@@ -65,7 +63,7 @@ func parseIntVal(path string) (int64, error) {
 func getSyncStatus(path string, size int64) (SyncStatus, error) {
 	raw, err := ioutil.ReadFile(filepath.Join(path, "md", "sync_completed"))
 	if err != nil {
-		return SyncStatus{}, errors.Wrap(err, "could not open sync_completed")
+		return SyncStatus{}, fmt.Errorf("could not open sync_completed: %w", err)
 	}
 	completedState := strings.TrimSpace(string(raw))
 	if completedState == "none" {
@@ -80,12 +78,12 @@ func getSyncStatus(path string, size int64) (SyncStatus, error) {
 
 	current, err := strconv.ParseInt(matches[0], 10, 64)
 	if err != nil {
-		return SyncStatus{}, errors.Wrap(err, "could not parse data sync_completed")
+		return SyncStatus{}, fmt.Errorf("could not parse data sync_completed: %w", err)
 	}
 
 	total, err := strconv.ParseInt(matches[1], 10, 64)
 	if err != nil {
-		return SyncStatus{}, errors.Wrap(err, "could not parse data sync_completed")
+		return SyncStatus{}, fmt.Errorf("could not parse data sync_completed: %w", err)
 	}
 
 	return SyncStatus{Complete: current, Total: total}, nil
@@ -99,27 +97,27 @@ func newMD(path string) (MDDevice, error) {
 	dev.Name = filepath.Base(path)
 	size, err := parseIntVal(filepath.Join(path, "size"))
 	if err != nil {
-		return dev, errors.Wrap(err, "could not get device size")
+		return dev, fmt.Errorf("could not get device size: %w", err)
 	}
 	dev.Size = size
 
 	//RAID array state
 	state, err := ioutil.ReadFile(filepath.Join(path, "md", "array_state"))
 	if err != nil {
-		return dev, errors.Wrap(err, "could not open array_state")
+		return dev, fmt.Errorf("could not open array_state: %w", err)
 	}
 	dev.ArrayState = strings.TrimSpace(string(state))
 
 	//get total disks
 	disks, err := getDisks(path)
 	if err != nil {
-		return dev, errors.Wrap(err, "could not get disk data")
+		return dev, fmt.Errorf("could not get disk data: %w", err)
 	}
 	dev.DiskStates = disks
 
 	level, err := ioutil.ReadFile(filepath.Join(path, "md", "level"))
 	if err != nil {
-		return dev, errors.Wrap(err, "could not get raid level")
+		return dev, fmt.Errorf("could not get raid level: %w", err)
 	}
 	dev.Level = strings.TrimSpace(string(level))
 
@@ -130,14 +128,14 @@ func newMD(path string) (MDDevice, error) {
 		//Will be idle if nothing is going on
 		syncAction, err := ioutil.ReadFile(filepath.Join(path, "md", "sync_action"))
 		if err != nil {
-			return dev, errors.Wrap(err, "could not open sync_action")
+			return dev, fmt.Errorf("could not open sync_action: %w", err)
 		}
 		dev.SyncAction = strings.TrimSpace(string(syncAction))
 
 		//sync status
 		syncStats, err := getSyncStatus(path, dev.Size)
 		if err != nil {
-			return dev, errors.Wrap(err, "error getting sync data")
+			return dev, fmt.Errorf("error getting sync data: %w", err)
 		}
 
 		dev.SyncStatus = syncStats
@@ -151,7 +149,7 @@ func getDisks(path string) (DiskStates, error) {
 	//so far, haven't found a less hacky way to do this.
 	devices, err := filepath.Glob(filepath.Join(path, "md", "dev-*"))
 	if err != nil {
-		return DiskStates{}, errors.Wrap(err, "could not get device list")
+		return DiskStates{}, fmt.Errorf("could not get device list: %w", err)
 	}
 
 	var disks DiskStates
@@ -191,7 +189,7 @@ func getDisks(path string) (DiskStates, error) {
 func getDisk(path string) (string, error) {
 	state, err := ioutil.ReadFile(filepath.Join(path, "state"))
 	if err != nil {
-		return "", errors.Wrap(err, "error getting disk state")
+		return "", fmt.Errorf("error getting disk state: %w", err)
 	}
 
 	return strings.TrimSpace(string(state)), nil
diff --git a/metricbeat/module/system/raid/raid.go b/metricbeat/module/system/raid/raid.go
index 238b067fd6f..191027657d7 100644
--- a/metricbeat/module/system/raid/raid.go
+++ b/metricbeat/module/system/raid/raid.go
@@ -18,7 +18,7 @@
 package raid
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
@@ -62,7 +62,7 @@ func blockto1024(b int64) int64 {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	devices, err := blockinfo.ListAll(m.mod.ResolveHostFS("/sys/block"))
 	if err != nil {
-		return errors.Wrap(err, "failed to parse sysfs")
+		return fmt.Errorf("failed to parse sysfs: %w", err)
 	}
 
 	for _, blockDev := range devices {
diff --git a/metricbeat/module/system/service/data.go b/metricbeat/module/system/service/data.go
index 1597beb6052..cb2329a7307 100644
--- a/metricbeat/module/system/service/data.go
+++ b/metricbeat/module/system/service/data.go
@@ -20,10 +20,10 @@
 package service
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/coreos/go-systemd/v22/dbus"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -63,7 +63,7 @@ type Properties struct {
 func formProperties(unit dbus.UnitStatus, props Properties) (mb.Event, error) {
 	timeSince, err := timeSince(props, unit.ActiveState)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error getting timestamp")
+		return mb.Event{}, fmt.Errorf("error getting timestamp: %w", err)
 	}
 
 	event := mb.Event{
diff --git a/metricbeat/module/system/service/service.go b/metricbeat/module/system/service/service.go
index 6a19c8b828c..f46e8c0287a 100644
--- a/metricbeat/module/system/service/service.go
+++ b/metricbeat/module/system/service/service.go
@@ -20,11 +20,11 @@
 package service
 
 import (
+	"fmt"
 	"path/filepath"
 
 	"github.com/coreos/go-systemd/v22/dbus"
 	"github.com/mitchellh/mapstructure"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -67,12 +67,12 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 
 	conn, err := dbus.New()
 	if err != nil {
-		return nil, errors.Wrap(err, "error connecting to dbus")
+		return nil, fmt.Errorf("error connecting to dbus: %w", err)
 	}
 
 	unitFunction, err := instrospectForUnitMethods()
 	if err != nil {
-		return nil, errors.Wrap(err, "error finding ListUnits Method")
+		return nil, fmt.Errorf("error finding ListUnits Method: %w", err)
 	}
 
 	return &MetricSet{
@@ -90,7 +90,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 
 	units, err := m.unitList(m.conn, m.cfg.StateFilter, m.cfg.PatternFilter)
 	if err != nil {
-		return errors.Wrap(err, "error getting list of running units")
+		return fmt.Errorf("error getting list of running units: %w", err)
 	}
 
 	for _, unit := range units {
@@ -134,11 +134,11 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 func getProps(conn *dbus.Conn, unit string) (Properties, error) {
 	rawProps, err := conn.GetAllProperties(unit)
 	if err != nil {
-		return Properties{}, errors.Wrap(err, "error getting list of running units")
+		return Properties{}, fmt.Errorf("error getting list of running units: %w", err)
 	}
 	parsed := Properties{}
 	if err := mapstructure.Decode(rawProps, &parsed); err != nil {
-		return parsed, errors.Wrap(err, "error decoding properties")
+		return parsed, fmt.Errorf("error decoding properties: %w", err)
 	}
 	return parsed, nil
 }
diff --git a/metricbeat/module/system/socket/socket.go b/metricbeat/module/system/socket/socket.go
index 1d6b1dc65f1..a0828d69b4f 100644
--- a/metricbeat/module/system/socket/socket.go
+++ b/metricbeat/module/system/socket/socket.go
@@ -27,8 +27,6 @@ import (
 	"strconv"
 	"syscall"
 
-	"github.com/pkg/errors"
-
 	sock "github.com/elastic/beats/v7/metricbeat/helper/socket"
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
@@ -119,7 +117,7 @@ func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 
 	sockets, err := m.netlink.GetSocketList()
 	if err != nil {
-		return errors.Wrap(err, "failed requesting socket dump")
+		return fmt.Errorf("failed requesting socket dump: %w", err)
 	}
 	debugf("netlink returned %d sockets", len(sockets))
 
diff --git a/metricbeat/module/system/socket/socket_test.go b/metricbeat/module/system/socket/socket_test.go
index 63b8712550b..3d27844f022 100644
--- a/metricbeat/module/system/socket/socket_test.go
+++ b/metricbeat/module/system/socket/socket_test.go
@@ -27,7 +27,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -153,7 +152,7 @@ func TestFetch(t *testing.T) {
 func getRequiredValue(t testing.TB, key string, m mapstr.M) interface{} {
 	v, err := m.GetValue(key)
 	if err != nil {
-		t.Fatal(errors.Wrapf(err, "failed to get value for key '%s'", key))
+		t.Fatal(fmt.Errorf("failed to get value for key '%s': %w", key, err))
 	}
 	if v == nil {
 		t.Fatalf("key %v not found in %v", key, m)
diff --git a/metricbeat/module/system/socket_summary/socket_summary.go b/metricbeat/module/system/socket_summary/socket_summary.go
index 57d4312fad9..5301887413a 100644
--- a/metricbeat/module/system/socket_summary/socket_summary.go
+++ b/metricbeat/module/system/socket_summary/socket_summary.go
@@ -18,9 +18,9 @@
 package socket_summary
 
 import (
+	"fmt"
 	"syscall"
 
-	"github.com/pkg/errors"
 	"github.com/shirou/gopsutil/v3/net"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -155,7 +155,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	conns, err := connections("inet")
 
 	if err != nil {
-		return errors.Wrap(err, "error getting connections")
+		return fmt.Errorf("error getting connections: %w", err)
 	}
 
 	stats := calculateConnStats(conns)
diff --git a/metricbeat/module/system/socket_summary/sockstat_linux.go b/metricbeat/module/system/socket_summary/sockstat_linux.go
index b198f322ff3..965cea3bd14 100644
--- a/metricbeat/module/system/socket_summary/sockstat_linux.go
+++ b/metricbeat/module/system/socket_summary/sockstat_linux.go
@@ -24,7 +24,6 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/pkg/errors"
 	"github.com/shirou/gopsutil/v3/net"
 
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -66,7 +65,7 @@ func applyEnhancements(data mapstr.M, sys resolve.Resolver) (mapstr.M, error) {
 
 	stat, err := parseSockstat(dir)
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting sockstat data")
+		return nil, fmt.Errorf("error getting sockstat data: %w", err)
 	}
 	data.Put("tcp.all.orphan", stat.TCPOrphan)
 	data.Put("tcp.memory", pageSize*stat.TCPMem)
@@ -113,7 +112,7 @@ func parseSockstat(path string) (SockStat, error) {
 		txt := scanner.Text()
 		count, err := fmt.Sscanf(txt, scanfLines[iter], scanfOut[iter]...)
 		if err != nil {
-			return ss, errors.Wrap(err, "error reading sockstat")
+			return ss, fmt.Errorf("error reading sockstat: %w", err)
 		}
 		if count != len(scanfOut[iter]) {
 			return ss, fmt.Errorf("did not match fields in line %s", scanfLines[iter])
@@ -123,7 +122,7 @@ func parseSockstat(path string) (SockStat, error) {
 	}
 
 	if err = scanner.Err(); err != nil {
-		return ss, errors.Wrap(err, "error in scan")
+		return ss, fmt.Errorf("error in scan: %w", err)
 	}
 
 	return ss, nil
diff --git a/metricbeat/module/system/uptime/uptime.go b/metricbeat/module/system/uptime/uptime.go
index fa5640b92c0..20a03bdc13c 100644
--- a/metricbeat/module/system/uptime/uptime.go
+++ b/metricbeat/module/system/uptime/uptime.go
@@ -20,7 +20,7 @@
 package uptime
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
@@ -49,7 +49,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	var uptime sigar.Uptime
 	if err := uptime.Get(); err != nil {
-		return errors.Wrap(err, "failed to get uptime")
+		return fmt.Errorf("failed to get uptime: %w", err)
 	}
 
 	r.Event(mb.Event{
diff --git a/metricbeat/module/traefik/health/health.go b/metricbeat/module/traefik/health/health.go
index ec528d83a98..26861d7b32a 100644
--- a/metricbeat/module/traefik/health/health.go
+++ b/metricbeat/module/traefik/health/health.go
@@ -18,7 +18,7 @@
 package health
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -66,7 +66,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	data, err := m.http.FetchJSON()
 	if err != nil {
-		return errors.Wrap(err, "failed to sample health")
+		return fmt.Errorf("failed to sample health: %w", err)
 	}
 
 	metricSetFields, _ := eventMapping(data)
diff --git a/metricbeat/module/uwsgi/status/data.go b/metricbeat/module/uwsgi/status/data.go
index 6c690db50f9..23dd353290e 100644
--- a/metricbeat/module/uwsgi/status/data.go
+++ b/metricbeat/module/uwsgi/status/data.go
@@ -19,8 +19,7 @@ package status
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -81,7 +80,7 @@ func eventsMapping(content []byte, reporter mb.ReporterV2) error {
 	var stats uwsgiStat
 	err := json.Unmarshal(content, &stats)
 	if err != nil {
-		return errors.Wrap(err, "uwsgi statistics parsing failed")
+		return fmt.Errorf("uwsgi statistics parsing failed: %w", err)
 	}
 
 	totalRequests := 0
diff --git a/metricbeat/module/uwsgi/status/status.go b/metricbeat/module/uwsgi/status/status.go
index e343ada60c6..8ade1df3a8d 100644
--- a/metricbeat/module/uwsgi/status/status.go
+++ b/metricbeat/module/uwsgi/status/status.go
@@ -18,6 +18,7 @@
 package status
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -26,8 +27,6 @@ import (
 	"net/url"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/module/uwsgi"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -55,8 +54,7 @@ func fetchStatData(URL string) ([]byte, error) {
 
 	u, err := url.Parse(URL)
 	if err != nil {
-
-		return nil, errors.Wrap(err, "parsing uwsgi stats url failed")
+		return nil, fmt.Errorf("parsing uwsgi stats url failed: %w", err)
 	}
 
 	switch u.Scheme {
@@ -93,7 +91,7 @@ func fetchStatData(URL string) ([]byte, error) {
 
 	data, err := ioutil.ReadAll(reader)
 	if err != nil {
-		return nil, errors.Wrap(err, "uwsgi data read failed")
+		return nil, fmt.Errorf("uwsgi data read failed: %w", err)
 	}
 
 	return data, nil
diff --git a/metricbeat/module/vsphere/datastore/datastore.go b/metricbeat/module/vsphere/datastore/datastore.go
index 0afba2c7ca8..4ec84b4b74e 100644
--- a/metricbeat/module/vsphere/datastore/datastore.go
+++ b/metricbeat/module/vsphere/datastore/datastore.go
@@ -19,8 +19,7 @@ package datastore
 
 import (
 	"context"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/module/vsphere"
@@ -61,12 +60,12 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 
 	client, err := govmomi.NewClient(ctx, m.HostURL, m.Insecure)
 	if err != nil {
-		return errors.Wrap(err, "error in NewClient")
+		return fmt.Errorf("error in NewClient: %w", err)
 	}
 
 	defer func() {
 		if err := client.Logout(ctx); err != nil {
-			m.Logger().Debug(errors.Wrap(err, "error trying to logout from vshphere"))
+			m.Logger().Debug(fmt.Errorf("error trying to logout from vshphere: %w", err))
 		}
 	}()
 
@@ -77,19 +76,19 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 
 	v, err := mgr.CreateContainerView(ctx, c.ServiceContent.RootFolder, []string{"Datastore"}, true)
 	if err != nil {
-		return errors.Wrap(err, "error in CreateContainerView")
+		return fmt.Errorf("error in CreateContainerView: %w", err)
 	}
 
 	defer func() {
 		if err := v.Destroy(ctx); err != nil {
-			m.Logger().Debug(errors.Wrap(err, "error trying to destroy view from vshphere"))
+			m.Logger().Debug(fmt.Errorf("error trying to destroy view from vshphere: %w", err))
 		}
 	}()
 
 	// Retrieve summary property for all datastores
 	var dst []mo.Datastore
 	if err = v.Retrieve(ctx, []string{"Datastore"}, []string{"summary"}, &dst); err != nil {
-		return errors.Wrap(err, "error in Retrieve")
+		return fmt.Errorf("error in Retrieve: %w", err)
 	}
 
 	for _, ds := range dst {
diff --git a/metricbeat/module/vsphere/host/host.go b/metricbeat/module/vsphere/host/host.go
index b299d6b83b0..457d4a65452 100644
--- a/metricbeat/module/vsphere/host/host.go
+++ b/metricbeat/module/vsphere/host/host.go
@@ -19,11 +19,10 @@ package host
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/module/vsphere"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -66,12 +65,12 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 
 	client, err := govmomi.NewClient(ctx, m.HostURL, m.Insecure)
 	if err != nil {
-		return errors.Wrap(err, "error in NewClient")
+		return fmt.Errorf("error in NewClient: %w", err)
 	}
 
 	defer func() {
 		if err := client.Logout(ctx); err != nil {
-			m.Logger().Debug(errors.Wrap(err, "error trying to logout from vshphere"))
+			m.Logger().Debug(fmt.Errorf("error trying to logout from vshphere: %w", err))
 		}
 	}()
 
@@ -82,12 +81,12 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 
 	v, err := mgr.CreateContainerView(ctx, c.ServiceContent.RootFolder, []string{"HostSystem"}, true)
 	if err != nil {
-		return errors.Wrap(err, "error in CreateContainerView")
+		return fmt.Errorf("error in CreateContainerView: %w", err)
 	}
 
 	defer func() {
 		if err := v.Destroy(ctx); err != nil {
-			m.Logger().Debug(errors.Wrap(err, "error trying to destroy view from vshphere"))
+			m.Logger().Debug(fmt.Errorf("error trying to destroy view from vshphere: %w", err))
 		}
 	}()
 
@@ -95,7 +94,7 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 	var hst []mo.HostSystem
 	err = v.Retrieve(ctx, []string{"HostSystem"}, []string{"summary"}, &hst)
 	if err != nil {
-		return errors.Wrap(err, "error in Retrieve")
+		return fmt.Errorf("error in Retrieve: %w", err)
 	}
 
 	for _, hs := range hst {
diff --git a/metricbeat/module/vsphere/virtualmachine/virtualmachine.go b/metricbeat/module/vsphere/virtualmachine/virtualmachine.go
index 546a40fdbfb..fd1a20ee3a7 100644
--- a/metricbeat/module/vsphere/virtualmachine/virtualmachine.go
+++ b/metricbeat/module/vsphere/virtualmachine/virtualmachine.go
@@ -19,6 +19,7 @@ package virtualmachine
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -26,7 +27,6 @@ import (
 	"github.com/elastic/beats/v7/metricbeat/module/vsphere"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 
-	"github.com/pkg/errors"
 	"github.com/vmware/govmomi"
 	"github.com/vmware/govmomi/object"
 	"github.com/vmware/govmomi/property"
@@ -80,12 +80,12 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 
 	client, err := govmomi.NewClient(ctx, m.HostURL, m.Insecure)
 	if err != nil {
-		return errors.Wrap(err, "error in NewClient")
+		return fmt.Errorf("error in NewClient: %w", err)
 	}
 
 	defer func() {
 		if err := client.Logout(ctx); err != nil {
-			m.Logger().Debug(errors.Wrap(err, "error trying to logout from vshphere"))
+			m.Logger().Debug(fmt.Errorf("error trying to logout from vshphere: %w", err))
 		}
 	}()
 
@@ -97,7 +97,7 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 		var err error
 		customFieldsMap, err = setCustomFieldsMap(ctx, c)
 		if err != nil {
-			return errors.Wrap(err, "error in setCustomFieldsMap")
+			return fmt.Errorf("error in setCustomFieldsMap: %w", err)
 		}
 	}
 
@@ -106,12 +106,12 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 
 	v, err := mgr.CreateContainerView(ctx, c.ServiceContent.RootFolder, []string{"VirtualMachine"}, true)
 	if err != nil {
-		return errors.Wrap(err, "error in CreateContainerView")
+		return fmt.Errorf("error in CreateContainerView: %w", err)
 	}
 
 	defer func() {
 		if err := v.Destroy(ctx); err != nil {
-			m.Logger().Debug(errors.Wrap(err, "error trying to destroy view from vshphere"))
+			m.Logger().Debug(fmt.Errorf("error trying to destroy view from vshphere: %w", err))
 		}
 	}()
 
@@ -119,7 +119,7 @@ func (m *MetricSet) Fetch(ctx context.Context, reporter mb.ReporterV2) error {
 	var vmt []mo.VirtualMachine
 	err = v.Retrieve(ctx, []string{"VirtualMachine"}, []string{"summary"}, &vmt)
 	if err != nil {
-		return errors.Wrap(err, "error in Retrieve")
+		return fmt.Errorf("error in Retrieve: %w", err)
 	}
 
 	for _, vm := range vmt {
@@ -278,11 +278,11 @@ func setCustomFieldsMap(ctx context.Context, client *vim25.Client) (map[int32]st
 	customFieldsManager, err := object.GetCustomFieldsManager(client)
 
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get custom fields manager")
+		return nil, fmt.Errorf("failed to get custom fields manager: %w", err)
 	}
 	field, err := customFieldsManager.Field(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get custom fields")
+		return nil, fmt.Errorf("failed to get custom fields: %w", err)
 	}
 
 	for _, def := range field {
diff --git a/metricbeat/module/windows/perfmon/config.go b/metricbeat/module/windows/perfmon/config.go
index 3544b88683f..f16c9c3b324 100644
--- a/metricbeat/module/windows/perfmon/config.go
+++ b/metricbeat/module/windows/perfmon/config.go
@@ -20,9 +20,9 @@
 package perfmon
 
 import (
+	"errors"
+	"fmt"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 var allowedFormats = []string{"float", "large", "long"}
@@ -63,7 +63,7 @@ func (counter *QueryCounter) InitDefaults() {
 
 func (counter *QueryCounter) Validate() error {
 	if !isValidFormat(counter.Format) {
-		return errors.Errorf("initialization failed: format '%s' "+
+		return fmt.Errorf("initialization failed: format '%s' "+
 			"for counter '%s' is invalid (must be float, large or long)",
 			counter.Format, counter.Name)
 	}
diff --git a/metricbeat/module/windows/perfmon/data.go b/metricbeat/module/windows/perfmon/data.go
index 2565ab11604..9add5c03896 100644
--- a/metricbeat/module/windows/perfmon/data.go
+++ b/metricbeat/module/windows/perfmon/data.go
@@ -25,8 +25,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/helper/windows/pdh"
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -71,7 +69,7 @@ func (re *Reader) groupToEvents(counters map[string][]pdh.CounterValue) []mb.Eve
 			if _, ok := eventMap[eventKey]; !ok {
 				eventMap[eventKey] = &mb.Event{
 					MetricSetFields: mapstr.M{},
-					Error:           errors.Wrapf(val.Err.Error, "failed on query=%v", counterPath),
+					Error:           fmt.Errorf("failed on query=%v: %w", counterPath, val.Err.Error),
 				}
 				if val.Instance != "" {
 					// will ignore instance index
diff --git a/metricbeat/module/windows/perfmon/perfmon.go b/metricbeat/module/windows/perfmon/perfmon.go
index 084d9a7cc91..19f231383f1 100644
--- a/metricbeat/module/windows/perfmon/perfmon.go
+++ b/metricbeat/module/windows/perfmon/perfmon.go
@@ -20,7 +20,7 @@
 package perfmon
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 
@@ -48,7 +48,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 	}
 	reader, err := NewReader(config)
 	if err != nil {
-		return nil, errors.Wrap(err, "initialization of reader failed")
+		return nil, fmt.Errorf("initialization of reader failed: %w", err)
 	}
 	return &MetricSet{
 		BaseMetricSet: base,
@@ -69,12 +69,12 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	if m.reader.config.RefreshWildcardCounters {
 		err := m.reader.RefreshCounterPaths()
 		if err != nil {
-			return errors.Wrap(err, "failed retrieving counters")
+			return fmt.Errorf("failed retrieving counters: %w", err)
 		}
 	}
 	events, err := m.reader.Read()
 	if err != nil {
-		return errors.Wrap(err, "failed reading counters")
+		return fmt.Errorf("failed reading counters: %w", err)
 	}
 
 	for _, event := range events {
@@ -91,7 +91,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 func (m *MetricSet) Close() error {
 	err := m.reader.Close()
 	if err != nil {
-		return errors.Wrap(err, "failed to close pdh query")
+		return fmt.Errorf("failed to close pdh query: %w", err)
 	}
 	return nil
 }
diff --git a/metricbeat/module/windows/service/reader.go b/metricbeat/module/windows/service/reader.go
index 11e5c901f17..379d4cb738f 100644
--- a/metricbeat/module/windows/service/reader.go
+++ b/metricbeat/module/windows/service/reader.go
@@ -22,10 +22,10 @@ package service
 import (
 	"crypto/sha256"
 	"encoding/base64"
+	"fmt"
 	"strconv"
 	"syscall"
 
-	"github.com/pkg/errors"
 	"golang.org/x/sys/windows/registry"
 
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -53,7 +53,7 @@ type Reader struct {
 func NewReader() (*Reader, error) {
 	handle, err := openSCManager("", "", ScManagerEnumerateService|ScManagerConnect)
 	if err != nil {
-		return nil, errors.Wrap(err, "initialization failed")
+		return nil, fmt.Errorf("initialization failed: %w", err)
 	}
 
 	guid, err := getMachineGUID()
@@ -151,12 +151,12 @@ func getMachineGUID() (string, error) {
 
 	k, err := registry.OpenKey(key, path, registry.READ|registry.WOW64_64KEY)
 	if err != nil {
-		return "", errors.Wrapf(err, `failed to open HKLM\%v`, path)
+		return "", fmt.Errorf(`failed to open HKLM\%v: %w`, path, err)
 	}
 
 	guid, _, err := k.GetStringValue(name)
 	if err != nil {
-		return "", errors.Wrapf(err, `failed to get value of HKLM\%v\%v`, path, name)
+		return "", fmt.Errorf(`failed to get value of HKLM\%v\%v: %w`, path, name, err)
 	}
 
 	return guid, nil
diff --git a/metricbeat/module/windows/service/service_status.go b/metricbeat/module/windows/service/service_status.go
index f2a9ed853b1..571d324cb59 100644
--- a/metricbeat/module/windows/service/service_status.go
+++ b/metricbeat/module/windows/service/service_status.go
@@ -21,6 +21,7 @@ package service
 
 import (
 	"bytes"
+	"fmt"
 	"os"
 	"strconv"
 	"syscall"
@@ -30,7 +31,8 @@ import (
 
 	"github.com/elastic/beats/v7/libbeat/common"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	"golang.org/x/sys/windows"
 
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -146,7 +148,7 @@ func GetServiceStates(handle Handle, state ServiceEnumState, protectedServices m
 				servicesBuffer = make([]byte, len(servicesBuffer)+int(bytesNeeded))
 				continue
 			}
-			return nil, errors.Wrap(ServiceErrno(err.(syscall.Errno)), "error while calling the _EnumServicesStatusEx api")
+			return nil, fmt.Errorf("error while calling the _EnumServicesStatusEx api: %w", ServiceErrno(err.(syscall.Errno)))
 		}
 
 		break
@@ -213,7 +215,7 @@ func getServiceInformation(rawService *EnumServiceStatusProcess, servicesBuffer
 
 	serviceHandle, err := openServiceHandle(handle, service.ServiceName, ServiceQueryConfig)
 	if err != nil {
-		return service, errors.Wrapf(err, "error while opening service %s", service.ServiceName)
+		return service, fmt.Errorf("error while opening service %s: %w", service.ServiceName, err)
 	}
 
 	defer closeHandle(serviceHandle)
@@ -279,7 +281,7 @@ func getAdditionalServiceInfo(serviceHandle Handle, service *Status) error {
 				buffer = make([]byte, len(buffer)+int(bytesNeeded))
 				continue
 			}
-			return errors.Wrapf(ServiceErrno(err.(syscall.Errno)), "error while querying the service configuration %s", service.ServiceName)
+			return fmt.Errorf("error while querying the service configuration %s: %w", service.ServiceName, ServiceErrno(err.(syscall.Errno)))
 		}
 		serviceQueryConfig := (*QueryServiceConfig)(unsafe.Pointer(&buffer[0]))
 		service.StartType = ServiceStartType(serviceQueryConfig.DwStartType)
@@ -311,7 +313,7 @@ func getOptionalServiceInfo(serviceHandle Handle, service *Status) error {
 		if service.StartType == StartTypeAutomatic {
 			delayedInfoBuffer, err := queryServiceConfig2(serviceHandle, ConfigDelayedAutoStartInfo)
 			if err != nil {
-				return errors.Wrapf(err, "error while querying rhe service configuration %s", service.ServiceName)
+				return fmt.Errorf("error while querying rhe service configuration %s: %w", service.ServiceName, err)
 			}
 
 			delayedInfo = (*serviceDelayedAutoStartInfo)(unsafe.Pointer(&delayedInfoBuffer[0]))
diff --git a/metricbeat/module/zookeeper/mntr/mntr.go b/metricbeat/module/zookeeper/mntr/mntr.go
index cd4e1000352..f08c7d36287 100644
--- a/metricbeat/module/zookeeper/mntr/mntr.go
+++ b/metricbeat/module/zookeeper/mntr/mntr.go
@@ -44,11 +44,11 @@ ZooKeeper mntr Command Output
 package mntr
 
 import (
+	"fmt"
+
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 	"github.com/elastic/beats/v7/metricbeat/module/zookeeper"
-
-	"github.com/pkg/errors"
 )
 
 func init() {
@@ -75,12 +75,12 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	outputReader, err := zookeeper.RunCommand("mntr", m.Host(), m.Module().Config().Timeout)
 	if err != nil {
-		return errors.Wrap(err, "mntr command failed")
+		return fmt.Errorf("mntr command failed: %w", err)
 	}
 
 	serverID, err := zookeeper.ServerID(m.Host(), m.Module().Config().Timeout)
 	if err != nil {
-		return errors.Wrap(err, "error obtaining server id")
+		return fmt.Errorf("error obtaining server id: %w", err)
 	}
 
 	eventMapping(serverID, outputReader, r, m.Logger())
diff --git a/metricbeat/module/zookeeper/server/data.go b/metricbeat/module/zookeeper/server/data.go
index 3619d018119..9d389abf5bf 100644
--- a/metricbeat/module/zookeeper/server/data.go
+++ b/metricbeat/module/zookeeper/server/data.go
@@ -20,13 +20,14 @@ package server
 import (
 	"bufio"
 	"encoding/binary"
+	"fmt"
 	"io"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"errors"
 
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -69,7 +70,7 @@ func parseSrvr(i io.Reader, logger *logp.Logger) (mapstr.M, string, error) {
 		if strings.Contains(line, "Zxid") {
 			xid, err := parseZxid(line)
 			if err != nil {
-				err = errors.Wrapf(err, "error parsing 'zxid' line '%s'", line)
+				err = fmt.Errorf("error parsing 'zxid' line '%s': %w", line, err)
 				logger.Debug(err.Error())
 				continue
 			}
@@ -82,7 +83,7 @@ func parseSrvr(i io.Reader, logger *logp.Logger) (mapstr.M, string, error) {
 		if strings.Contains(line, "Latency") {
 			latency, err := parseLatencyLine(line)
 			if err != nil {
-				err = errors.Wrapf(err, "error parsing 'latency values' line '%s'", line)
+				err = fmt.Errorf("error parsing 'latency values' line '%s': %w", line, err)
 				logger.Debug(err.Error())
 				continue
 			}
@@ -95,7 +96,7 @@ func parseSrvr(i io.Reader, logger *logp.Logger) (mapstr.M, string, error) {
 		if strings.Contains(line, "Proposal sizes") {
 			proposalSizes, err := parseProposalSizes(line)
 			if err != nil {
-				err = errors.Wrapf(err, "error parsing 'proposal sizes' line '%s'", line)
+				err = fmt.Errorf("error parsing 'proposal sizes' line '%s': %w", line, err)
 				logger.Debug(err.Error())
 				continue
 			}
@@ -138,7 +139,7 @@ func parseSrvr(i io.Reader, logger *logp.Logger) (mapstr.M, string, error) {
 
 			val, err := strconv.ParseInt(result[2], 10, 64)
 			if err != nil {
-				err = errors.Wrapf(err, "error trying to parse value '%s' as int", result[2])
+				err = fmt.Errorf("error trying to parse value '%s' as int: %w", result[2], err)
 				logger.Debug(err.Error())
 				continue
 			}
@@ -155,16 +156,16 @@ func parseZxid(line string) (mapstr.M, error) {
 
 	zxidSplit := strings.Split(line, " ")
 	if len(zxidSplit) < 2 {
-		return nil, errors.Errorf("less than 2 tokens (%v) after splitting", zxidSplit)
+		return nil, fmt.Errorf("less than 2 tokens (%v) after splitting", zxidSplit)
 	}
 
 	zxidString := zxidSplit[1]
 	if len(zxidString) < 3 {
-		return nil, errors.Errorf("less than 3 characters on '%s'", zxidString)
+		return nil, fmt.Errorf("less than 3 characters on '%s'", zxidString)
 	}
 	zxid, err := strconv.ParseInt(zxidString[2:], 16, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse value '%s' to int", zxidString[2:])
+		return nil, fmt.Errorf("error trying to parse value '%s' to int: %w", zxidString[2:], err)
 	}
 
 	bs := make([]byte, 8)
@@ -185,28 +186,28 @@ func parseProposalSizes(line string) (mapstr.M, error) {
 
 	initialSplit := strings.Split(line, " ")
 	if len(initialSplit) < 4 {
-		return nil, errors.Errorf("less than 4 tokens (%v) after splitting", initialSplit)
+		return nil, fmt.Errorf("less than 4 tokens (%v) after splitting", initialSplit)
 	}
 
 	values := strings.Split(initialSplit[3], "/")
 	if len(values) < 3 {
-		return nil, errors.Errorf("less than 3 tokens (%v) after splitting", values)
+		return nil, fmt.Errorf("less than 3 tokens (%v) after splitting", values)
 	}
 	last, err := strconv.ParseInt(values[0], 10, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse 'last' value as int from '%s'", values[0])
+		return nil, fmt.Errorf("error trying to parse 'last' value as int from '%s': %w", values[0], err)
 	}
 	output.Put("last", last)
 
 	min, err := strconv.ParseInt(values[1], 10, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse 'min' value as int from '%s'", values[1])
+		return nil, fmt.Errorf("error trying to parse 'min' value as int from '%s': %w", values[1], err)
 	}
 	output.Put("min", min)
 
 	max, err := strconv.ParseInt(values[2], 10, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse 'max' value as int from '%s'", values[2])
+		return nil, fmt.Errorf("error trying to parse 'max' value as int from '%s': %w", values[2], err)
 	}
 	output.Put("max", max)
 
@@ -218,24 +219,24 @@ func parseLatencyLine(line string) (mapstr.M, error) {
 
 	values := latencyCapturer.FindStringSubmatch(line)
 	if len(values) < 4 {
-		return nil, errors.Errorf("less than 4 fields (%v) after splitting", values)
+		return nil, fmt.Errorf("less than 4 fields (%v) after splitting", values)
 	}
 
 	min, err := strconv.ParseInt(values[1], 10, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse 'min' value '%s' as int", values[1])
+		return nil, fmt.Errorf("error trying to parse 'min' value '%s' as int: %w", values[1], err)
 	}
 	output.Put("min", min)
 
 	avg, err := strconv.ParseInt(values[2], 10, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse 'avg' value '%s' as int", values[2])
+		return nil, fmt.Errorf("error trying to parse 'avg' value '%s' as int: %w", values[2], err)
 	}
 	output.Put("avg", avg)
 
 	max, err := strconv.ParseInt(values[3], 10, 64)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error trying to parse 'max' value '%s' as int", values[3])
+		return nil, fmt.Errorf("error trying to parse 'max' value '%s' as int: %w", values[3], err)
 	}
 	output.Put("max", max)
 
diff --git a/metricbeat/module/zookeeper/server/server.go b/metricbeat/module/zookeeper/server/server.go
index 141556a5fb3..86dde3df443 100644
--- a/metricbeat/module/zookeeper/server/server.go
+++ b/metricbeat/module/zookeeper/server/server.go
@@ -39,7 +39,7 @@ Proposal sizes last/min/max: -3/-999/-1
 package server
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
@@ -71,18 +71,18 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(reporter mb.ReporterV2) error {
 	outputReader, err := zookeeper.RunCommand("srvr", m.Host(), m.Module().Config().Timeout)
 	if err != nil {
-		return errors.Wrap(err, "srvr command failed")
+		return fmt.Errorf("srvr command failed: %w", err)
 
 	}
 
 	metricsetFields, version, err := parseSrvr(outputReader, m.Logger())
 	if err != nil {
-		return errors.Wrap(err, "error parsing srvr output")
+		return fmt.Errorf("error parsing srvr output: %w", err)
 	}
 
 	serverID, err := zookeeper.ServerID(m.Host(), m.Module().Config().Timeout)
 	if err != nil {
-		return errors.Wrap(err, "error obtaining server id")
+		return fmt.Errorf("error obtaining server id: %w", err)
 	}
 
 	event := mb.Event{
diff --git a/metricbeat/module/zookeeper/zookeeper.go b/metricbeat/module/zookeeper/zookeeper.go
index 745080d7435..3c8c4573177 100644
--- a/metricbeat/module/zookeeper/zookeeper.go
+++ b/metricbeat/module/zookeeper/zookeeper.go
@@ -23,13 +23,13 @@ package zookeeper
 import (
 	"bufio"
 	"bytes"
+	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"net"
 	"strings"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 // RunCommand establishes a TCP connection the ZooKeeper command port that
@@ -39,7 +39,7 @@ import (
 func RunCommand(command, address string, timeout time.Duration) (io.Reader, error) {
 	conn, err := net.DialTimeout("tcp", address, timeout)
 	if err != nil {
-		return nil, errors.Wrapf(err, "connection to host '%s' failed", address)
+		return nil, fmt.Errorf("connection to host '%s' failed: %w", address, err)
 	}
 	defer conn.Close()
 
@@ -52,12 +52,12 @@ func RunCommand(command, address string, timeout time.Duration) (io.Reader, erro
 	// Write four-letter command.
 	_, err = conn.Write([]byte(command))
 	if err != nil {
-		return nil, errors.Wrapf(err, "writing command '%s' failed", command)
+		return nil, fmt.Errorf("writing command '%s' failed: %w", command, err)
 	}
 
 	result, err := ioutil.ReadAll(conn)
 	if err != nil {
-		return nil, errors.Wrap(err, "read failed")
+		return nil, fmt.Errorf("read failed: %w", err)
 	}
 
 	return bytes.NewReader(result), nil
@@ -67,7 +67,7 @@ func RunCommand(command, address string, timeout time.Duration) (io.Reader, erro
 func ServerID(address string, timeout time.Duration) (string, error) {
 	response, err := RunCommand("conf", address, timeout)
 	if err != nil {
-		return "", errors.Wrap(err, "execution of 'conf' command failed")
+		return "", fmt.Errorf("execution of 'conf' command failed: %w", err)
 	}
 
 	scanner := bufio.NewScanner(response)
diff --git a/metricbeat/scripts/mage/docs_collector.go b/metricbeat/scripts/mage/docs_collector.go
index b505db79a69..9d270905e6c 100644
--- a/metricbeat/scripts/mage/docs_collector.go
+++ b/metricbeat/scripts/mage/docs_collector.go
@@ -29,7 +29,6 @@ import (
 	"text/template"
 
 	"github.com/magefile/mage/sh"
-	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 
 	"github.com/elastic/beats/v7/dev-tools/mage"
@@ -61,12 +60,12 @@ type metricsetData struct {
 func writeTemplate(filename string, t *template.Template, args interface{}) error {
 	fd, err := os.Create(filename)
 	if err != nil {
-		return errors.Wrapf(err, "error opening file at %s", filename)
+		return fmt.Errorf("error opening file at %s: %w", filename, err)
 	}
 	defer fd.Close()
 	err = t.Execute(fd, args)
 	if err != nil {
-		return errors.Wrap(err, "error executing template")
+		return fmt.Errorf("error executing template: %w", err)
 	}
 	return nil
 }
@@ -150,7 +149,7 @@ func getDefaultMetricsets() (map[string][]string, error) {
 	for _, dir := range runpaths {
 		rawMap, err := sh.OutCmd("go", append(cmd, dir)...)()
 		if err != nil {
-			return nil, errors.Wrap(err, "Error running subcommand to get metricsets")
+			return nil, fmt.Errorf("Error running subcommand to get metricsets: %w", err)
 		}
 		var msetMap = make(map[string][]string)
 		err = json.Unmarshal([]byte(rawMap), &msetMap)
@@ -169,7 +168,7 @@ func getDefaultMetricsets() (map[string][]string, error) {
 func loadModuleFields(file string) (moduleData, error) {
 	fd, err := ioutil.ReadFile(file)
 	if err != nil {
-		return moduleData{}, errors.Wrap(err, "failed to read from spec file")
+		return moduleData{}, fmt.Errorf("failed to read from spec file: %w", err)
 	}
 	// Cheat and use the same struct.
 	var mod []moduleData
@@ -180,7 +179,7 @@ func loadModuleFields(file string) (moduleData, error) {
 
 	rel, err := getRelease(module.Release)
 	if err != nil {
-		return mod[0], errors.Wrapf(err, "file %s is missing a release string", file)
+		return mod[0], fmt.Errorf("file %s is missing a release string: %w", file, err)
 	}
 	module.Release = rel
 
@@ -191,7 +190,7 @@ func loadModuleFields(file string) (moduleData, error) {
 func getReleaseState(metricsetPath string) (string, error) {
 	raw, err := ioutil.ReadFile(metricsetPath)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to read from spec file")
+		return "", fmt.Errorf("failed to read from spec file: %w", err)
 	}
 
 	type metricset struct {
@@ -204,7 +203,7 @@ func getReleaseState(metricsetPath string) (string, error) {
 
 	relString, err := getRelease(rel[0].Release)
 	if err != nil {
-		return "", errors.Wrapf(err, "metricset %s is missing a release tag", metricsetPath)
+		return "", fmt.Errorf("metricset %s is missing a release tag: %w", metricsetPath, err)
 	}
 	return relString, nil
 }
@@ -298,7 +297,7 @@ func gatherMetricsets(modulePath string, moduleName string, defaultMetricSets []
 func gatherData(modules []string) ([]moduleData, error) {
 	defmset, err := getDefaultMetricsets()
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting default metricsets")
+		return nil, fmt.Errorf("error getting default metricsets: %w", err)
 	}
 	moduleList := make([]moduleData, 0)
 	//iterate over all the modules, checking to make sure we have an asciidoc file
@@ -377,7 +376,7 @@ func writeMetricsetDocs(modules []moduleData, t *template.Template) error {
 			filename := mage.OSSBeatDir("docs", "modules", mod.Base, fmt.Sprintf("%s.asciidoc", metricset.Title))
 			err := writeTemplate(filename, t.Lookup("metricsetDoc.tmpl"), modData)
 			if err != nil {
-				return errors.Wrapf(err, "error opening file at %s", filename)
+				return fmt.Errorf("error opening file at %s: %w", filename, err)
 			}
 		} // end metricset loop
 	} // end module loop
@@ -403,25 +402,25 @@ func writeDocs(modules []moduleData) error {
 	tmplList := template.New("moduleList").Option("missingkey=error").Funcs(funcMap)
 	beatPath, err := mage.ElasticBeatsDir()
 	if err != nil {
-		return errors.Wrap(err, "error finding beats dir")
+		return fmt.Errorf("error finding beats dir: %w", err)
 	}
 	tmplList, err = tmplList.ParseGlob(path.Join(beatPath, "metricbeat/scripts/mage/template/*.tmpl"))
 	if err != nil {
-		return errors.Wrap(err, "error parsing template files")
+		return fmt.Errorf("error parsing template files: %w", err)
 	}
 
 	err = writeModuleDocs(modules, tmplList)
 	if err != nil {
-		return errors.Wrap(err, "error writing module docs")
+		return fmt.Errorf("error writing module docs: %w", err)
 	}
 	err = writeMetricsetDocs(modules, tmplList)
 	if err != nil {
-		return errors.Wrap(err, "error writing metricset docs")
+		return fmt.Errorf("error writing metricset docs: %w", err)
 	}
 
 	err = writeModuleList(modules, tmplList)
 	if err != nil {
-		return errors.Wrap(err, "error writing module list")
+		return fmt.Errorf("error writing module list: %w", err)
 	}
 
 	return nil
diff --git a/metricbeat/scripts/mage/package.go b/metricbeat/scripts/mage/package.go
index 6ba347bf6f8..e206881dd3c 100644
--- a/metricbeat/scripts/mage/package.go
+++ b/metricbeat/scripts/mage/package.go
@@ -26,7 +26,6 @@ import (
 	"strings"
 
 	"github.com/magefile/mage/mg"
-	"github.com/pkg/errors"
 
 	devtools "github.com/elastic/beats/v7/dev-tools/mage"
 )
@@ -58,7 +57,7 @@ func CustomizePackaging() {
 			Modules: true,
 			Dep: func(spec devtools.PackageSpec) error {
 				if err := devtools.Copy(dirModulesDGenerated, spec.MustExpand("{{.PackageDir}}/modules.d")); err != nil {
-					return errors.Wrap(err, "failed to copy modules.d dir")
+					return fmt.Errorf("failed to copy modules.d dir: %w", err)
 				}
 
 				return devtools.FindReplace(
@@ -73,7 +72,7 @@ func CustomizePackaging() {
 				err := devtools.Copy("metricbeat.reference.yml",
 					spec.MustExpand("{{.PackageDir}}/metricbeat.reference.yml"))
 				if err != nil {
-					return errors.Wrap(err, "failed to copy reference config")
+					return fmt.Errorf("failed to copy reference config: %w", err)
 				}
 
 				return devtools.FindReplace(
@@ -96,7 +95,7 @@ func CustomizePackaging() {
 			case devtools.Deb, devtools.RPM:
 				args.Spec.Files["/etc/{{.BeatName}}/"+modulesDTarget] = modulesD
 			default:
-				panic(errors.Errorf("unhandled package type: %v", pkgType))
+				panic(fmt.Errorf("unhandled package type: %v", pkgType))
 			}
 		}
 	}
@@ -171,7 +170,7 @@ func GenerateDirModulesD() error {
 
 	docBranch, err := devtools.BeatDocBranch()
 	if err != nil {
-		errors.Wrap(err, "failed to get doc branch")
+		return fmt.Errorf("failed to get doc branch: %w", err)
 	}
 
 	mode := 0644
@@ -297,21 +296,24 @@ func moduleConfigParts(f string) (moduleName string, configName string, ok bool)
 func copyWithHeader(header, src, dst string, mode os.FileMode) error {
 	dstFile, err := os.OpenFile(devtools.CreateDir(dst), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, mode&os.ModePerm)
 	if err != nil {
-		return errors.Wrap(err, "failed to open copy destination")
+		return fmt.Errorf("failed to open copy destination: %w", err)
 	}
 	defer dstFile.Close()
 
 	_, err = io.WriteString(dstFile, header+"\n\n")
 	if err != nil {
-		return errors.Wrap(err, "failed to write header")
+		return fmt.Errorf("failed to write header: %w", err)
 	}
 
 	srcFile, err := os.Open(src)
 	if err != nil {
-		return errors.Wrap(err, "failed to open copy source")
+		return fmt.Errorf("failed to open copy source: %w", err)
 	}
 	defer srcFile.Close()
 
 	_, err = io.Copy(dstFile, srcFile)
-	return errors.Wrap(err, "failed to copy file")
+	if err != nil {
+		return fmt.Errorf("failed to copy file: %w", err)
+	}
+	return nil
 }
diff --git a/packetbeat/pb/event.go b/packetbeat/pb/event.go
index 3c38f98729b..44cb7c81d92 100644
--- a/packetbeat/pb/event.go
+++ b/packetbeat/pb/event.go
@@ -24,8 +24,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/beat"
 	"github.com/elastic/beats/v7/libbeat/common"
 	"github.com/elastic/beats/v7/libbeat/common/flowhash"
@@ -112,7 +110,7 @@ func GetFields(m mapstr.M) (*Fields, error) {
 
 	fields, ok := v.(*Fields)
 	if !ok {
-		return nil, errors.Errorf("%v must be a *types.Fields, but is %T", FieldsKey, fields)
+		return nil, fmt.Errorf("%v must be a *types.Fields, but is %T", FieldsKey, fields)
 	}
 	return fields, nil
 }
diff --git a/packetbeat/protos/http/decode.go b/packetbeat/protos/http/decode.go
index 34301955e9b..dc113f53de9 100644
--- a/packetbeat/protos/http/decode.go
+++ b/packetbeat/protos/http/decode.go
@@ -23,7 +23,7 @@ import (
 	"compress/gzip"
 	"io"
 
-	"github.com/pkg/errors"
+	"errors"
 )
 
 var (
diff --git a/packetbeat/protos/http/http.go b/packetbeat/protos/http/http.go
index 91706a5e30d..6c291e8e83a 100644
--- a/packetbeat/protos/http/http.go
+++ b/packetbeat/protos/http/http.go
@@ -27,8 +27,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/beat"
 	"github.com/elastic/beats/v7/libbeat/common"
 	"github.com/elastic/beats/v7/libbeat/ecs"
@@ -708,7 +706,7 @@ func decodeBody(body []byte, encodings []string, maxSize int) (result []byte, er
 			if idx != 0 {
 				body = nil
 			}
-			return body, errors.Wrapf(err, "unable to decode body using %s encoding", format)
+			return body, fmt.Errorf("unable to decode body using %s encoding: %w", format, err)
 		}
 	}
 	return body, nil
diff --git a/packetbeat/publish/publish.go b/packetbeat/publish/publish.go
index 9c64727de35..257ad027a70 100644
--- a/packetbeat/publish/publish.go
+++ b/packetbeat/publish/publish.go
@@ -18,10 +18,9 @@
 package publish
 
 import (
+	"errors"
 	"net"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/beat"
 	"github.com/elastic/beats/v7/libbeat/common"
 	"github.com/elastic/beats/v7/libbeat/processors"
diff --git a/packetbeat/scripts/mage/package.go b/packetbeat/scripts/mage/package.go
index fdbb2b69bb5..76373df2b73 100644
--- a/packetbeat/scripts/mage/package.go
+++ b/packetbeat/scripts/mage/package.go
@@ -18,11 +18,10 @@
 package mage
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
-	"github.com/pkg/errors"
-
 	devtools "github.com/elastic/beats/v7/dev-tools/mage"
 )
 
@@ -93,7 +92,7 @@ func CustomizePackaging() {
 		case devtools.Docker:
 			args.Spec.ExtraVar("linux_capabilities", "cap_net_raw,cap_net_admin+eip")
 		default:
-			panic(errors.Errorf("unhandled package type: %v", pkgType))
+			panic(fmt.Errorf("unhandled package type: %v", pkgType))
 		}
 	}
 }
diff --git a/winlogbeat/scripts/mage/docs.go b/winlogbeat/scripts/mage/docs.go
index 0b59d3e79b1..510ae7558ec 100644
--- a/winlogbeat/scripts/mage/docs.go
+++ b/winlogbeat/scripts/mage/docs.go
@@ -25,8 +25,6 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/dev-tools/mage"
 )
 
@@ -58,7 +56,7 @@ func moduleDocs() error {
 		return err
 	}
 	if len(files) == 0 {
-		return errors.Errorf("No modules found matching %v", searchPath)
+		return fmt.Errorf("No modules found matching %v", searchPath)
 	}
 
 	// Clean existing files.
@@ -71,7 +69,7 @@ func moduleDocs() error {
 	for _, f := range files {
 		matches := moduleNameRegex.FindStringSubmatch(filepath.ToSlash(f))
 		if len(matches) != 2 {
-			return errors.Errorf("module path %v does not match regexp", f)
+			return fmt.Errorf("module path %v does not match regexp", f)
 		}
 		name := matches[1]
 		names = append(names, name)
diff --git a/winlogbeat/scripts/mage/package.go b/winlogbeat/scripts/mage/package.go
index 81e090092bd..20cde9f551b 100644
--- a/winlogbeat/scripts/mage/package.go
+++ b/winlogbeat/scripts/mage/package.go
@@ -23,7 +23,6 @@ import (
 	"time"
 
 	"github.com/magefile/mage/mg"
-	"github.com/pkg/errors"
 
 	devtools "github.com/elastic/beats/v7/dev-tools/mage"
 	"github.com/elastic/beats/v7/dev-tools/mage/target/build"
@@ -86,7 +85,7 @@ func customizePackaging() {
 			case devtools.Deb, devtools.RPM:
 				args.Spec.Files["/etc/{{.BeatName}}/module"] = moduleDir
 			default:
-				panic(errors.Errorf("unhandled package type: %v", pkgType))
+				panic(fmt.Errorf("unhandled package type: %v", pkgType))
 			}
 		}
 	}
diff --git a/x-pack/dockerlogbeat/handlers.go b/x-pack/dockerlogbeat/handlers.go
index 8b3a771a741..31466d44b65 100644
--- a/x-pack/dockerlogbeat/handlers.go
+++ b/x-pack/dockerlogbeat/handlers.go
@@ -6,6 +6,7 @@ package main
 
 import (
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
 
@@ -14,7 +15,6 @@ import (
 	"github.com/elastic/beats/v7/x-pack/dockerlogbeat/pipelinemanager"
 
 	"github.com/docker/docker/pkg/ioutils"
-	"github.com/pkg/errors"
 )
 
 // StartLoggingRequest represents the request object we get on a call to //LogDriver.StartLogging
@@ -54,7 +54,7 @@ func startLoggingHandler(pm *pipelinemanager.PipelineManager) func(w http.Respon
 		var startReq StartLoggingRequest
 		err := json.NewDecoder(r.Body).Decode(&startReq)
 		if err != nil {
-			http.Error(w, errors.Wrap(err, "error decoding json request").Error(), http.StatusBadRequest)
+			http.Error(w, fmt.Sprintf("error decoding json request: %v", err), http.StatusBadRequest)
 			return
 		}
 
@@ -64,13 +64,13 @@ func startLoggingHandler(pm *pipelinemanager.PipelineManager) func(w http.Respon
 
 		cfg, err := pipelinemanager.NewCfgFromRaw(startReq.Info.Config)
 		if err != nil {
-			http.Error(w, errors.Wrap(err, "error creating client config").Error(), http.StatusBadRequest)
+			http.Error(w, fmt.Errorf("error creating client config: %w", err).Error(), http.StatusBadRequest)
 			return
 		}
 		pm.Logger.Debugf("Got config: %#v", cfg)
 		cl, err := pm.CreateClientWithConfig(cfg, startReq.Info, startReq.File)
 		if err != nil {
-			http.Error(w, errors.Wrap(err, "error creating client").Error(), http.StatusBadRequest)
+			http.Error(w, fmt.Errorf("error creating client: %w", err).Error(), http.StatusBadRequest)
 			return
 		}
 
@@ -86,7 +86,7 @@ func stopLoggingHandler(pm *pipelinemanager.PipelineManager) func(w http.Respons
 		var stopReq StopLoggingRequest
 		err := json.NewDecoder(r.Body).Decode(&stopReq)
 		if err != nil {
-			http.Error(w, errors.Wrap(err, "error decoding json request").Error(), http.StatusBadRequest)
+			http.Error(w, fmt.Errorf("error decoding json request: %w", err).Error(), http.StatusBadRequest)
 			return
 		}
 		pm.Logger.Debugf("Got stop request object %#v\n", stopReq)
@@ -108,14 +108,14 @@ func readLogHandler(pm *pipelinemanager.PipelineManager) func(w http.ResponseWri
 		var logReq logsRequest
 		err := json.NewDecoder(r.Body).Decode(&logReq)
 		if err != nil {
-			http.Error(w, errors.Wrap(err, "error decoding json request").Error(), http.StatusBadRequest)
+			http.Error(w, fmt.Errorf("error decoding json request: %w", err).Error(), http.StatusBadRequest)
 			return
 		}
 
 		pm.Logger.Debugf("Got logging request for container %s\n", logReq.Info.ContainerName)
 		stream, err := pm.CreateReaderForContainer(logReq.Info, logReq.Config)
 		if err != nil {
-			http.Error(w, errors.Wrap(err, "error creating log reader").Error(), http.StatusBadRequest)
+			http.Error(w, fmt.Errorf("error creating log reader: %w", err).Error(), http.StatusBadRequest)
 			return
 		}
 		defer stream.Close()
diff --git a/x-pack/dockerlogbeat/magefile.go b/x-pack/dockerlogbeat/magefile.go
index 3b848ce92c0..73da67186d7 100644
--- a/x-pack/dockerlogbeat/magefile.go
+++ b/x-pack/dockerlogbeat/magefile.go
@@ -24,7 +24,6 @@ import (
 	"github.com/docker/docker/client"
 	"github.com/magefile/mage/mg"
 	"github.com/magefile/mage/sh"
-	"github.com/pkg/errors"
 
 	devtools "github.com/elastic/beats/v7/dev-tools/mage"
 	// mage:import
@@ -71,7 +70,7 @@ func init() {
 func getPluginName() (string, error) {
 	version, err := devtools.BeatQualifiedVersion()
 	if err != nil {
-		return "", errors.Wrap(err, "error getting beats version")
+		return "", fmt.Errorf("error getting beats version: %w", err)
 	}
 	return dockerPluginName + ":" + version, nil
 }
@@ -80,35 +79,35 @@ func getPluginName() (string, error) {
 func createContainer(ctx context.Context, cli *client.Client, arch string) error {
 	dockerLogBeatDir, err := os.Getwd()
 	if err != nil {
-		return errors.Wrap(err, "error getting work dir")
+		return fmt.Errorf("error getting work dir: %w", err)
 	}
 
 	if !strings.Contains(dockerLogBeatDir, "dockerlogbeat") {
-		return errors.Errorf("not in dockerlogbeat directory: %s", dockerLogBeatDir)
+		return fmt.Errorf("not in dockerlogbeat directory: %s", dockerLogBeatDir)
 	}
 
 	dockerfile := filepath.Join(packageStagingDir, "Dockerfile")
 	err = devtools.ExpandFile(dockerfileTmpl, dockerfile, platformMap[arch])
 	if err != nil {
-		return errors.Wrap(err, "error while expanding Dockerfile template")
+		return fmt.Errorf("error while expanding Dockerfile template: %w", err)
 	}
 
 	// start to build the root container that'll be used to build the plugin
 	tmpDir, err := ioutil.TempDir("", "dockerBuildTar")
 	if err != nil {
-		return errors.Wrap(err, "error locating temp dir")
+		return fmt.Errorf("error locating temp dir: %w", err)
 	}
 	defer sh.Rm(tmpDir)
 
 	tarPath := filepath.Join(tmpDir, "tarRoot.tar")
 	err = sh.RunV("tar", "cf", tarPath, "./")
 	if err != nil {
-		return errors.Wrap(err, "error creating tar")
+		return fmt.Errorf("error creating tar: %w", err)
 	}
 
 	buildContext, err := os.Open(tarPath)
 	if err != nil {
-		return errors.Wrap(err, "error opening temp dur")
+		return fmt.Errorf("error opening temp dur: %w", err)
 	}
 	defer buildContext.Close()
 
@@ -119,13 +118,13 @@ func createContainer(ctx context.Context, cli *client.Client, arch string) error
 	// build, wait for output
 	buildResp, err := cli.ImageBuild(ctx, buildContext, buildOpts)
 	if err != nil {
-		return errors.Wrap(err, "error building final container image")
+		return fmt.Errorf("error building final container image: %w", err)
 	}
 	defer buildResp.Body.Close()
 	// This blocks until the build operation completes
 	buildStr, errBufRead := ioutil.ReadAll(buildResp.Body)
 	if errBufRead != nil {
-		return errors.Wrap(err, "error reading from docker output")
+		return fmt.Errorf("error reading from docker output: %w", errBufRead)
 	}
 	fmt.Printf("%s\n", string(buildStr))
 
@@ -143,14 +142,14 @@ func BuildContainer(ctx context.Context) error {
 	// setup
 	cli, err := newDockerClient(ctx)
 	if err != nil {
-		return errors.Wrap(err, "error creating docker client")
+		return fmt.Errorf("error creating docker client: %w", err)
 	}
 
 	devtools.CreateDir(packageStagingDir)
 	devtools.CreateDir(packageEndDir)
 	err = os.MkdirAll(filepath.Join(buildDir, "rootfs"), 0755)
 	if err != nil {
-		return errors.Wrap(err, "error creating build dir")
+		return fmt.Errorf("error creating build dir: %w", err)
 	}
 
 	for _, plat := range devtools.Platforms {
@@ -162,13 +161,13 @@ func BuildContainer(ctx context.Context) error {
 
 		err = createContainer(ctx, cli, arch)
 		if err != nil {
-			return errors.Wrap(err, "error creating base container")
+			return fmt.Errorf("error creating base container: %w", err)
 		}
 
 		// create the container that will become our rootfs
 		CreatedContainerBody, err := cli.ContainerCreate(ctx, &container.Config{Image: rootImageName}, nil, nil, nil, "")
 		if err != nil {
-			return errors.Wrap(err, "error creating container")
+			return fmt.Errorf("error creating container: %w", err)
 		}
 
 		defer func() {
@@ -185,31 +184,31 @@ func BuildContainer(ctx context.Context) error {
 
 		file, err := os.Create(dockerExportPath)
 		if err != nil {
-			return errors.Wrap(err, "error creating tar archive")
+			return fmt.Errorf("error creating tar archive: %w", err)
 		}
 
 		// export the container to a tar file
 		exportReader, err := cli.ContainerExport(ctx, CreatedContainerBody.ID)
 		if err != nil {
-			return errors.Wrap(err, "error exporting container")
+			return fmt.Errorf("error exporting container: %w", err)
 		}
 
 		_, err = io.Copy(file, exportReader)
 		if err != nil {
-			return errors.Wrap(err, "error writing exported container")
+			return fmt.Errorf("error writing exported container: %w", err)
 		}
 
 		// misc prepare operations
 
 		err = devtools.Copy("config.json", filepath.Join(buildDir, "config.json"))
 		if err != nil {
-			return errors.Wrap(err, "error copying config.json")
+			return fmt.Errorf("error copying config.json: %w", err)
 		}
 
 		// unpack the tar file into a root directory, which is the format needed for the docker plugin create tool
 		err = sh.RunV("tar", "-xf", dockerExportPath, "-C", filepath.Join(buildDir, "rootfs"))
 		if err != nil {
-			return errors.Wrap(err, "error unpacking exported container")
+			return fmt.Errorf("error unpacking exported container: %w", err)
 		}
 	}
 
@@ -220,12 +219,12 @@ func cleanDockerArtifacts(ctx context.Context, containerID string, cli *client.C
 	fmt.Printf("Removing container %s\n", containerID)
 	err := cli.ContainerRemove(ctx, containerID, types.ContainerRemoveOptions{RemoveVolumes: true, Force: true})
 	if err != nil {
-		return errors.Wrap(err, "error removing container")
+		return fmt.Errorf("error removing container: %w", err)
 	}
 
 	resp, err := cli.ImageRemove(ctx, rootImageName, types.ImageRemoveOptions{Force: true})
 	if err != nil {
-		return errors.Wrap(err, "error removing image")
+		return fmt.Errorf("error removing image: %w", err)
 	}
 	fmt.Printf("Removed image: %#v\n", resp)
 	return nil
@@ -235,13 +234,13 @@ func cleanDockerArtifacts(ctx context.Context, containerID string, cli *client.C
 func Uninstall(ctx context.Context) error {
 	cli, err := newDockerClient(ctx)
 	if err != nil {
-		return errors.Wrap(err, "error creating docker client")
+		return fmt.Errorf("error creating docker client: %w", err)
 	}
 
 	// check to see if we have a plugin we need to remove
 	plugins, err := cli.PluginList(ctx, filters.Args{})
 	if err != nil {
-		return errors.Wrap(err, "error getting list of plugins")
+		return fmt.Errorf("error getting list of plugins: %w", err)
 	}
 
 	toRemoveName := ""
@@ -257,11 +256,11 @@ func Uninstall(ctx context.Context) error {
 
 	err = cli.PluginDisable(ctx, toRemoveName, types.PluginDisableOptions{Force: true})
 	if err != nil {
-		return errors.Wrap(err, "error disabling plugin")
+		return fmt.Errorf("error disabling plugin: %w", err)
 	}
 	err = cli.PluginRemove(ctx, toRemoveName, types.PluginRemoveOptions{Force: true})
 	if err != nil {
-		return errors.Wrap(err, "error removing plugin")
+		return fmt.Errorf("error removing plugin: %w", err)
 	}
 
 	return nil
@@ -281,22 +280,22 @@ func Install(ctx context.Context) error {
 
 	cli, err := newDockerClient(ctx)
 	if err != nil {
-		return errors.Wrap(err, "error creating docker client")
+		return fmt.Errorf("error creating docker client: %w", err)
 	}
 
 	archive, err := tar(buildDir, "rootfs", "config.json")
 	if err != nil {
-		return errors.Wrap(err, "error creating archive of work dir")
+		return fmt.Errorf("error creating archive of work dir: %w", err)
 	}
 
 	err = cli.PluginCreate(ctx, archive, types.PluginCreateOptions{RepoName: name})
 	if err != nil {
-		return errors.Wrap(err, "error creating plugin")
+		return fmt.Errorf("error creating plugin: %w", err)
 	}
 
 	err = cli.PluginEnable(ctx, name, types.PluginEnableOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error enabling plugin")
+		return fmt.Errorf("error enabling plugin: %w", err)
 	}
 
 	return nil
@@ -308,7 +307,7 @@ func tar(dir string, files ...string) (io.Reader, error) {
 	args := append([]string{"-C", dir, "-cf", "-"}, files...)
 	_, err := sh.Exec(nil, &archive, &stdErr, "tar", args...)
 	if err != nil {
-		return nil, errors.Wrap(err, stdErr.String())
+		return nil, fmt.Errorf(stdErr.String()+": %w", err)
 	}
 
 	return &archive, nil
@@ -318,7 +317,7 @@ func tar(dir string, files ...string) (io.Reader, error) {
 func Export() error {
 	version, err := devtools.BeatQualifiedVersion()
 	if err != nil {
-		return errors.Wrap(err, "error getting beats version")
+		return fmt.Errorf("error getting beats version: %w", err)
 	}
 
 	if devtools.Snapshot {
@@ -333,16 +332,20 @@ func Export() error {
 
 		err = os.Chdir(packageStagingDir)
 		if err != nil {
-			return errors.Wrap(err, "error changing directory")
+			return fmt.Errorf("error changing directory: %w", err)
 		}
 
 		err = sh.RunV("tar", "zcf", outpath,
 			filepath.Join(logDriverName, "rootfs"),
 			filepath.Join(logDriverName, "config.json"))
 		if err != nil {
-			return errors.Wrap(err, "error creating release tarball")
+			return fmt.Errorf("error creating release tarball: %w", err)
 		}
-		return errors.Wrap(devtools.CreateSHA512File(outpath), "failed to create .sha512 file")
+
+		if err = devtools.CreateSHA512File(outpath); err != nil {
+			return fmt.Errorf("failed to create .sha512 file: %w", err)
+		}
+		return nil
 	}
 
 	return nil
diff --git a/x-pack/dockerlogbeat/pipelinemanager/config.go b/x-pack/dockerlogbeat/pipelinemanager/config.go
index 46a10a7fe6b..b6bbf3a26fe 100644
--- a/x-pack/dockerlogbeat/pipelinemanager/config.go
+++ b/x-pack/dockerlogbeat/pipelinemanager/config.go
@@ -5,10 +5,10 @@
 package pipelinemanager
 
 import (
+	"errors"
+	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/common/transform/typeconv"
 	"github.com/elastic/elastic-agent-libs/config"
 )
@@ -66,11 +66,11 @@ func (cfg ContainerOutputConfig) CreateConfig() (*config.C, error) {
 	var tmp map[string]interface{}
 	err := typeconv.Convert(&tmp, cfg)
 	if err != nil {
-		return nil, errors.Wrap(err, "error converting config struct to interface")
+		return nil, fmt.Errorf("error converting config struct to interface: %w", err)
 	}
 	cfgFinal, err := config.NewConfigFrom(tmp)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating config object")
+		return nil, fmt.Errorf("error creating config object: %w", err)
 	}
 
 	return cfgFinal, nil
diff --git a/x-pack/dockerlogbeat/pipelinemanager/pipelineManager.go b/x-pack/dockerlogbeat/pipelinemanager/pipelineManager.go
index 9115027e110..1e0179d2fa3 100644
--- a/x-pack/dockerlogbeat/pipelinemanager/pipelineManager.go
+++ b/x-pack/dockerlogbeat/pipelinemanager/pipelineManager.go
@@ -17,8 +17,6 @@ import (
 	"github.com/elastic/beats/v7/x-pack/dockerlogbeat/pipereader"
 	"github.com/elastic/elastic-agent-libs/config"
 
-	"github.com/pkg/errors"
-
 	"github.com/docker/docker/api/types/plugins/logdriver"
 	"github.com/docker/docker/daemon/logger"
 	"github.com/docker/docker/daemon/logger/jsonfilelog"
@@ -77,7 +75,7 @@ func (pm *PipelineManager) CloseClientWithFile(file string) error {
 
 	cl, err := pm.removeClient(file)
 	if err != nil {
-		return errors.Wrap(err, "Error removing client")
+		return fmt.Errorf("Error removing client: %w", err)
 	}
 
 	hash := cl.pipelineHash
@@ -88,7 +86,7 @@ func (pm *PipelineManager) CloseClientWithFile(file string) error {
 	pm.Logger.Debugf("Closing Client first from pipelineManager")
 	err = cl.Close()
 	if err != nil {
-		return errors.Wrap(err, "error closing client")
+		return fmt.Errorf("error closing client: %w", err)
 	}
 
 	// if the pipeline is no longer in use, clean up
@@ -103,16 +101,16 @@ func (pm *PipelineManager) CreateClientWithConfig(containerConfig ContainerOutpu
 
 	hashstring, err := hashstructure.Hash(containerConfig, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating config hash")
+		return nil, fmt.Errorf("error creating config hash: %w", err)
 	}
 	pipeline, err := pm.getOrCreatePipeline(containerConfig, hashstring)
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting pipeline")
+		return nil, fmt.Errorf("error getting pipeline: %w", err)
 	}
 
 	reader, err := pipereader.NewReaderFromPath(file)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating reader for docker log stream")
+		return nil, fmt.Errorf("error creating reader for docker log stream: %w", err)
 	}
 
 	// Why is this empty by default? What should be here? Who knows!
@@ -121,7 +119,7 @@ func (pm *PipelineManager) CreateClientWithConfig(containerConfig ContainerOutpu
 	}
 	err = os.MkdirAll(filepath.Dir(info.LogPath), 0755)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating directory for local logs")
+		return nil, fmt.Errorf("error creating directory for local logs: %w", err)
 	}
 	// set a default log size
 	if _, ok := info.Config["max-size"]; !ok {
@@ -134,13 +132,13 @@ func (pm *PipelineManager) CreateClientWithConfig(containerConfig ContainerOutpu
 
 	localLog, err := jsonfilelog.New(info)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating local log")
+		return nil, fmt.Errorf("error creating local log: %w", err)
 	}
 
 	//actually get to crafting the new client.
 	cl, err := newClientFromPipeline(pipeline.pipeline, reader, hashstring, info, localLog, pm.hostname)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating client")
+		return nil, fmt.Errorf("error creating client: %w", err)
 	}
 
 	pm.registerClient(cl, hashstring, file)
@@ -211,7 +209,7 @@ func (pm *PipelineManager) getOrCreatePipeline(logOptsConfig ContainerOutputConf
 	if !test {
 		pipeline, err = loadNewPipeline(logOptsConfig, pm.hostname, pm.Logger)
 		if err != nil {
-			return nil, errors.Wrap(err, "error loading pipeline")
+			return nil, fmt.Errorf("error loading pipeline: %w", err)
 		}
 		pm.pipelines[hash] = pipeline
 	}
diff --git a/x-pack/dockerlogbeat/pipelinemanager/selector.go b/x-pack/dockerlogbeat/pipelinemanager/selector.go
index 624e8528b09..637837a35b1 100644
--- a/x-pack/dockerlogbeat/pipelinemanager/selector.go
+++ b/x-pack/dockerlogbeat/pipelinemanager/selector.go
@@ -7,8 +7,6 @@ package pipelinemanager
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/beat"
 	"github.com/elastic/beats/v7/libbeat/outputs"
 	"github.com/elastic/beats/v7/libbeat/outputs/outil"
@@ -36,7 +34,7 @@ func (s *IdxSupport) BuildSelector(cfg *config.C) (outputs.IndexSelector, error)
 	if cfg.HasField("indicies") {
 		sub, err := cfg.Child("indices", -1)
 		if err != nil {
-			return nil, errors.Wrap(err, "error getting indicies field")
+			return nil, fmt.Errorf("error getting indicies field: %w", err)
 		}
 		bsCfg.SetChild("indices", -1, sub)
 	}
@@ -64,7 +62,7 @@ func (s *IdxSupport) BuildSelector(cfg *config.C) (outputs.IndexSelector, error)
 
 	indexSel, err := outil.BuildSelectorFromConfig(bsCfg, buildSettings)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating build Selector")
+		return nil, fmt.Errorf("error creating build Selector: %w", err)
 	}
 
 	return indexSel, nil
diff --git a/x-pack/dockerlogbeat/pipereader/reader.go b/x-pack/dockerlogbeat/pipereader/reader.go
index d1f8eb05c21..6ca20f301b3 100644
--- a/x-pack/dockerlogbeat/pipereader/reader.go
+++ b/x-pack/dockerlogbeat/pipereader/reader.go
@@ -7,6 +7,7 @@ package pipereader
 import (
 	"context"
 	"encoding/binary"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"syscall"
@@ -14,7 +15,6 @@ import (
 	"github.com/containerd/fifo"
 	"github.com/docker/docker/api/types/plugins/logdriver"
 	"github.com/gogo/protobuf/proto"
-	"github.com/pkg/errors"
 )
 
 // PipeReader reads from the FIFO pipe we get from the docker container
@@ -30,7 +30,7 @@ type PipeReader struct {
 func NewReaderFromPath(file string) (*PipeReader, error) {
 	inputFile, err := fifo.OpenFifo(context.Background(), file, syscall.O_RDONLY, 0700)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error opening logger fifo: %q", file)
+		return nil, fmt.Errorf("error opening logger fifo: %q: %w", file, err)
 	}
 
 	return &PipeReader{fifoPipe: inputFile, byteOrder: binary.BigEndian, lenFrameBuf: make([]byte, 4), bodyBuf: nil, maxSize: 2e6}, nil
@@ -63,7 +63,7 @@ func (reader *PipeReader) ReadMessage(log *logdriver.LogEntry) error {
 		// 2) we have a too-large message. Disregard length bytes
 		_, err = io.CopyBuffer(ioutil.Discard, io.LimitReader(reader.fifoPipe, int64(lenFrame)), reader.bodyBuf)
 		if err != nil {
-			return errors.Wrap(err, "error emptying buffer")
+			return fmt.Errorf("error emptying buffer: %w", err)
 		}
 	}
 
@@ -71,7 +71,7 @@ func (reader *PipeReader) ReadMessage(log *logdriver.LogEntry) error {
 	readBuf := reader.setBuffer(lenFrame)
 	_, err = io.ReadFull(reader.fifoPipe, readBuf[:lenFrame])
 	if err != nil {
-		return errors.Wrap(err, "error reading buffer")
+		return fmt.Errorf("error reading buffer: %w", err)
 	}
 	return proto.Unmarshal(readBuf[:lenFrame], log)
 
diff --git a/x-pack/filebeat/input/awss3/script.go b/x-pack/filebeat/input/awss3/script.go
index cd05e73e976..525f953b618 100644
--- a/x-pack/filebeat/input/awss3/script.go
+++ b/x-pack/filebeat/input/awss3/script.go
@@ -6,6 +6,7 @@ package awss3
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -13,7 +14,6 @@ import (
 	"strings"
 
 	"github.com/dop251/goja"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/libbeat/common"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -87,12 +87,12 @@ func loadSources(files ...string) (string, []byte, error) {
 
 		f, err := os.Open(path)
 		if err != nil {
-			return errors.Wrapf(err, "failed to open file %v", path)
+			return fmt.Errorf("failed to open file %v: %w", path, err)
 		}
 		defer f.Close()
 
 		if _, err = io.Copy(buf, f); err != nil {
-			return errors.Wrapf(err, "failed to read file %v", path)
+			return fmt.Errorf("failed to read file %v: %w", path, err)
 		}
 		return nil
 	}
@@ -112,7 +112,7 @@ func loadSources(files ...string) (string, []byte, error) {
 	}
 
 	if len(sources) == 0 {
-		return "", nil, errors.Errorf("no sources were found in %v",
+		return "", nil, fmt.Errorf("no sources were found in %v",
 			strings.Join(files, ", "))
 	}
 
diff --git a/x-pack/filebeat/input/awss3/script_jss3event_v2.go b/x-pack/filebeat/input/awss3/script_jss3event_v2.go
index 04cea00a08b..f998c9bf295 100644
--- a/x-pack/filebeat/input/awss3/script_jss3event_v2.go
+++ b/x-pack/filebeat/input/awss3/script_jss3event_v2.go
@@ -5,10 +5,11 @@
 package awss3
 
 import (
+	"errors"
+	"fmt"
 	"strings"
 
 	"github.com/dop251/goja"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/libbeat/common/encoding/xml"
 )
@@ -60,7 +61,7 @@ func newXMLDecoderConstructor(s *session) func(call goja.ConstructorCall) *goja.
 		s0, ok := a0.(string)
 
 		if !ok {
-			panic(errors.Errorf("Event constructor requires a "+
+			panic(fmt.Errorf("Event constructor requires a "+
 				"string argument but got %T", a0))
 		}
 
diff --git a/x-pack/filebeat/input/awss3/script_session.go b/x-pack/filebeat/input/awss3/script_session.go
index 2418943b394..af852496f56 100644
--- a/x-pack/filebeat/input/awss3/script_session.go
+++ b/x-pack/filebeat/input/awss3/script_session.go
@@ -5,12 +5,12 @@
 package awss3
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"time"
 
 	"github.com/dop251/goja"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -93,7 +93,7 @@ func (s *session) setParseFunction() error {
 		return errors.New("parse is not a function")
 	}
 	if err := s.vm.ExportTo(parseFunc, &s.parseFunc); err != nil {
-		return errors.Wrap(err, "failed to export parse function")
+		return fmt.Errorf("failed to export parse function: %w", err)
 	}
 	return nil
 }
@@ -109,10 +109,10 @@ func (s *session) registerScriptParams(params map[string]interface{}) error {
 	}
 	var register goja.Callable
 	if err := s.vm.ExportTo(registerFunc, &register); err != nil {
-		return errors.Wrap(err, "failed to export register function")
+		return fmt.Errorf("failed to export register function: %w", err)
 	}
 	if _, err := register(goja.Undefined(), s.vm.ToValue(params)); err != nil {
-		return errors.Wrap(err, "failed to register script_params")
+		return fmt.Errorf("failed to register script_params: %w", err)
 	}
 	s.log.Debug("Registered params with script")
 	return nil
@@ -127,11 +127,11 @@ func (s *session) executeTestFunction() error {
 		}
 		var test goja.Callable
 		if err := s.vm.ExportTo(testFunc, &test); err != nil {
-			return errors.Wrap(err, "failed to export test function")
+			return fmt.Errorf("failed to export test function: %w", err)
 		}
 		_, err := test(goja.Undefined(), nil)
 		if err != nil {
-			return errors.Wrap(err, "failed in test() function")
+			return fmt.Errorf("failed in test() function: %w", err)
 		}
 		s.log.Debugf("Successful test() execution for script.")
 	}
diff --git a/x-pack/filebeat/input/netflow/decoder/decoder.go b/x-pack/filebeat/input/netflow/decoder/decoder.go
index 993c373c881..0e1ef3df92c 100644
--- a/x-pack/filebeat/input/netflow/decoder/decoder.go
+++ b/x-pack/filebeat/input/netflow/decoder/decoder.go
@@ -7,14 +7,13 @@ package decoder
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 	"log"
 	"net"
 	"sync"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/config"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/protocol"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/record"
@@ -59,7 +58,7 @@ func (p *Decoder) Start() error {
 	for _, proto := range p.protos {
 		if err := proto.Start(); err != nil {
 			p.stop()
-			return errors.Wrapf(err, "failed to start protocol version %d", proto.Version())
+			return fmt.Errorf("failed to start protocol version %d: %w", proto.Version(), err)
 		}
 	}
 	p.started = true
diff --git a/x-pack/filebeat/input/netflow/decoder/v1/v1.go b/x-pack/filebeat/input/netflow/decoder/v1/v1.go
index 8d9008c9393..e023341c4ad 100644
--- a/x-pack/filebeat/input/netflow/decoder/v1/v1.go
+++ b/x-pack/filebeat/input/netflow/decoder/v1/v1.go
@@ -7,13 +7,12 @@ package v1
 import (
 	"bytes"
 	"encoding/binary"
+	"fmt"
 	"io"
 	"log"
 	"net"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/config"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/fields"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/protocol"
@@ -92,11 +91,11 @@ func (p *NetflowProtocol) OnPacket(buf *bytes.Buffer, source net.Addr) (flows []
 	numFlows, timestamp, metadata, err := p.readHeader(buf, source)
 	if err != nil {
 		p.logger.Printf("Failed parsing packet: %v", err)
-		return nil, errors.Wrap(err, "error reading netflow header")
+		return nil, fmt.Errorf("error reading netflow header: %w", err)
 	}
 	flows, err = p.flowTemplate.Apply(buf, numFlows)
 	if err != nil {
-		return nil, errors.Wrap(err, "error parsing flows")
+		return nil, fmt.Errorf("error parsing flows: %w", err)
 	}
 	for i := range flows {
 		flows[i].Exporter = metadata
diff --git a/x-pack/filebeat/input/netflow/decoder/v8/v8.go b/x-pack/filebeat/input/netflow/decoder/v8/v8.go
index 855b8d3c914..9fa88ea1c68 100644
--- a/x-pack/filebeat/input/netflow/decoder/v8/v8.go
+++ b/x-pack/filebeat/input/netflow/decoder/v8/v8.go
@@ -13,8 +13,6 @@ import (
 	"net"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/config"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/fields"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/protocol"
@@ -323,7 +321,7 @@ func (p *NetflowV8Protocol) OnPacket(buf *bytes.Buffer, source net.Addr) (flows
 	header, err := ReadPacketHeader(buf)
 	if err != nil {
 		p.logger.Printf("Failed parsing packet: %v", err)
-		return nil, errors.Wrap(err, "error reading V8 header")
+		return nil, fmt.Errorf("error reading V8 header: %w", err)
 	}
 	template, found := templates[header.Aggregation]
 	if !found {
@@ -333,7 +331,7 @@ func (p *NetflowV8Protocol) OnPacket(buf *bytes.Buffer, source net.Addr) (flows
 	metadata := header.GetMetadata(source)
 	flows, err = template.Apply(buf, int(header.Count))
 	if err != nil {
-		return nil, errors.Wrapf(err, "unable to decode V8 flows of type %d", header.Aggregation)
+		return nil, fmt.Errorf("unable to decode V8 flows of type %d: %w", header.Aggregation, err)
 	}
 	for i := range flows {
 		flows[i].Exporter = metadata
diff --git a/x-pack/filebeat/input/netflow/decoder/v9/v9.go b/x-pack/filebeat/input/netflow/decoder/v9/v9.go
index e70bda4ab3b..fdb46076c87 100644
--- a/x-pack/filebeat/input/netflow/decoder/v9/v9.go
+++ b/x-pack/filebeat/input/netflow/decoder/v9/v9.go
@@ -6,12 +6,11 @@ package v9
 
 import (
 	"bytes"
+	"fmt"
 	"log"
 	"net"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/config"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/protocol"
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/record"
@@ -76,7 +75,7 @@ func (p *NetflowV9Protocol) OnPacket(buf *bytes.Buffer, source net.Addr) (flows
 	header, payload, numFlowSets, err := p.decoder.ReadPacketHeader(buf)
 	if err != nil {
 		p.logger.Printf("Unable to read V9 header: %v", err)
-		return nil, errors.Wrapf(err, "error reading header")
+		return nil, fmt.Errorf("error reading header: %w", err)
 	}
 	buf = payload
 
@@ -105,7 +104,7 @@ func (p *NetflowV9Protocol) OnPacket(buf *bytes.Buffer, source net.Addr) (flows
 		f, err := p.parseSet(set.SetID, session, body)
 		if err != nil {
 			p.logger.Printf("Error parsing set %d: %v", set.SetID, err)
-			return nil, errors.Wrapf(err, "error parsing set")
+			return nil, fmt.Errorf("error parsing set: %w", err)
 		}
 		flows = append(flows, f...)
 	}
diff --git a/x-pack/filebeat/input/netflow/definitions.go b/x-pack/filebeat/input/netflow/definitions.go
index 267abef5a92..62e6dc3f1b0 100644
--- a/x-pack/filebeat/input/netflow/definitions.go
+++ b/x-pack/filebeat/input/netflow/definitions.go
@@ -5,13 +5,13 @@
 package netflow
 
 import (
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"math"
 	"os"
 	"strconv"
 
-	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
 
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/netflow/decoder/fields"
@@ -64,7 +64,7 @@ func LoadFieldDefinitions(yaml interface{}) (defs fields.FieldDict, err error) {
 	defs = fields.FieldDict{}
 	if !isIPFIX {
 		if err := loadFields(tree, 0, defs); err != nil {
-			return nil, errors.Wrap(err, "failed to load NetFlow fields")
+			return nil, fmt.Errorf("failed to load NetFlow fields: %w", err)
 		}
 		return defs, nil
 	}
@@ -81,7 +81,7 @@ func LoadFieldDefinitions(yaml interface{}) (defs fields.FieldDict, err error) {
 			return nil, fmt.Errorf("IPFIX fields for pem=%d malformed", pem)
 		}
 		if err := loadFields(tree, uint32(pem), defs); err != nil {
-			return nil, errors.Wrapf(err, "failed to load IPFIX fields for pem=%d", pem)
+			return nil, fmt.Errorf("failed to load IPFIX fields for pem=%d: %w", pem, err)
 		}
 	}
 	return defs, nil
@@ -101,7 +101,7 @@ func LoadFieldDefinitionsFromFile(path string) (defs fields.FieldDict, err error
 	}
 	var tree interface{}
 	if err := yaml.Unmarshal(contents, &tree); err != nil {
-		return nil, errors.Wrap(err, "unable to parse YAML")
+		return nil, fmt.Errorf("unable to parse YAML: %w", err)
 	}
 	return LoadFieldDefinitions(tree)
 }
diff --git a/x-pack/filebeat/input/netflow/input.go b/x-pack/filebeat/input/netflow/input.go
index 16aa958396d..97f9931f325 100644
--- a/x-pack/filebeat/input/netflow/input.go
+++ b/x-pack/filebeat/input/netflow/input.go
@@ -6,12 +6,11 @@ package netflow
 
 import (
 	"bytes"
+	"fmt"
 	"net"
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/filebeat/channel"
 	"github.com/elastic/beats/v7/filebeat/harvester"
 	"github.com/elastic/beats/v7/filebeat/input"
@@ -108,7 +107,7 @@ func NewInput(
 	for _, yamlPath := range config.CustomDefinitions {
 		f, err := LoadFieldDefinitionsFromFile(yamlPath)
 		if err != nil {
-			return nil, errors.Wrapf(err, "failed parsing custom field definitions from file '%s'", yamlPath)
+			return nil, fmt.Errorf("failed parsing custom field definitions from file '%s': %w", yamlPath, err)
 		}
 		customFields = append(customFields, f)
 	}
@@ -120,7 +119,7 @@ func NewInput(
 		WithSequenceResetEnabled(config.DetectSequenceReset).
 		WithSharedTemplates(config.ShareTemplates))
 	if err != nil {
-		return nil, errors.Wrapf(err, "error initializing netflow decoder")
+		return nil, fmt.Errorf("error initializing netflow decoder: %w", err)
 	}
 
 	input := &netflowInput{
diff --git a/x-pack/filebeat/input/o365audit/auth/auth.go b/x-pack/filebeat/input/o365audit/auth/auth.go
index 69899e34031..6b0fea75c12 100644
--- a/x-pack/filebeat/input/o365audit/auth/auth.go
+++ b/x-pack/filebeat/input/o365audit/auth/auth.go
@@ -5,8 +5,9 @@
 package auth
 
 import (
+	"fmt"
+
 	"github.com/Azure/go-autorest/autorest/adal"
-	"github.com/pkg/errors"
 )
 
 // TokenProvider is the interface that wraps an authentication mechanism and
@@ -28,7 +29,7 @@ type servicePrincipalToken adal.ServicePrincipalToken
 func (provider *servicePrincipalToken) Token() (string, error) {
 	inner := (*adal.ServicePrincipalToken)(provider)
 	if err := inner.EnsureFresh(); err != nil {
-		return "", errors.Wrap(err, "refreshing spt token")
+		return "", fmt.Errorf("refreshing spt token: %w", err)
 	}
 	token := inner.Token()
 	return token.OAuthToken(), nil
diff --git a/x-pack/filebeat/input/o365audit/auth/cert.go b/x-pack/filebeat/input/o365audit/auth/cert.go
index 1d0dc9f7526..f4912e0afc4 100644
--- a/x-pack/filebeat/input/o365audit/auth/cert.go
+++ b/x-pack/filebeat/input/o365audit/auth/cert.go
@@ -10,7 +10,6 @@ import (
 	"fmt"
 
 	"github.com/Azure/go-autorest/autorest/adal"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/elastic-agent-libs/transport/tlscommon"
 )
@@ -22,11 +21,11 @@ func NewProviderFromCertificate(
 	conf tlscommon.CertificateConfig) (sptp TokenProvider, err error) {
 	cert, privKey, err := loadConfigCerts(conf)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed loading certificates")
+		return nil, fmt.Errorf("failed loading certificates: %w", err)
 	}
 	oauth, err := adal.NewOAuthConfig(endpoint, tenantID)
 	if err != nil {
-		return nil, errors.Wrap(err, "error generating OAuthConfig")
+		return nil, fmt.Errorf("error generating OAuthConfig: %w", err)
 	}
 
 	spt, err := adal.NewServicePrincipalTokenFromCertificate(
@@ -46,14 +45,14 @@ func NewProviderFromCertificate(
 func loadConfigCerts(cfg tlscommon.CertificateConfig) (cert *x509.Certificate, key *rsa.PrivateKey, err error) {
 	tlsCert, err := tlscommon.LoadCertificate(&cfg)
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "error loading X509 certificate from '%s'", cfg.Certificate)
+		return nil, nil, fmt.Errorf("error loading X509 certificate from '%s': %w", cfg.Certificate, err)
 	}
 	if tlsCert == nil || len(tlsCert.Certificate) == 0 {
 		return nil, nil, fmt.Errorf("no certificates loaded from '%s'", cfg.Certificate)
 	}
 	cert, err = x509.ParseCertificate(tlsCert.Certificate[0])
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "error parsing X509 certificate from '%s'", cfg.Certificate)
+		return nil, nil, fmt.Errorf("error parsing X509 certificate from '%s': %w", cfg.Certificate, err)
 	}
 	if tlsCert.PrivateKey == nil {
 		return nil, nil, fmt.Errorf("failed loading private key from '%s'", cfg.Key)
diff --git a/x-pack/filebeat/input/o365audit/auth/secret.go b/x-pack/filebeat/input/o365audit/auth/secret.go
index c34d6d48cc6..98b5c9dbfda 100644
--- a/x-pack/filebeat/input/o365audit/auth/secret.go
+++ b/x-pack/filebeat/input/o365audit/auth/secret.go
@@ -5,8 +5,9 @@
 package auth
 
 import (
+	"fmt"
+
 	"github.com/Azure/go-autorest/autorest/adal"
-	"github.com/pkg/errors"
 )
 
 // NewProviderFromClientSecret returns a token provider that uses a secret
@@ -14,7 +15,7 @@ import (
 func NewProviderFromClientSecret(endpoint, resource, applicationID, tenantID, secret string) (p TokenProvider, err error) {
 	oauth, err := adal.NewOAuthConfig(endpoint, tenantID)
 	if err != nil {
-		return nil, errors.Wrap(err, "error generating OAuthConfig")
+		return nil, fmt.Errorf("error generating OAuthConfig: %w", err)
 	}
 	spt, err := adal.NewServicePrincipalToken(*oauth, applicationID, secret, resource)
 	if err != nil {
diff --git a/x-pack/filebeat/input/o365audit/config.go b/x-pack/filebeat/input/o365audit/config.go
index d6178e9cbcc..dd419c54679 100644
--- a/x-pack/filebeat/input/o365audit/config.go
+++ b/x-pack/filebeat/input/o365audit/config.go
@@ -5,12 +5,11 @@
 package o365audit
 
 import (
+	"errors"
 	"fmt"
 	"net/url"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/o365audit/auth"
 	"github.com/elastic/elastic-agent-libs/transport/tlscommon"
 )
@@ -147,16 +146,16 @@ func (c *Config) Validate() (err error) {
 	}
 	if hasCert {
 		if err = c.CertificateConfig.Validate(); err != nil {
-			return errors.Wrap(err, "invalid certificate config")
+			return fmt.Errorf("invalid certificate config: %w", err)
 		}
 	}
 	c.API.Resource, err = forceURLScheme(c.API.Resource, "https")
 	if err != nil {
-		return errors.Wrapf(err, "resource '%s' is not a valid URL", c.API.Resource)
+		return fmt.Errorf("resource '%s' is not a valid URL: %w", c.API.Resource, err)
 	}
 	c.API.AuthenticationEndpoint, err = forceURLScheme(c.API.AuthenticationEndpoint, "https")
 	if err != nil {
-		return errors.Wrapf(err, "authentication_endpoint '%s' is not a valid URL", c.API.AuthenticationEndpoint)
+		return fmt.Errorf("authentication_endpoint '%s' is not a valid URL: %w", c.API.AuthenticationEndpoint, err)
 	}
 	return nil
 }
diff --git a/x-pack/filebeat/input/o365audit/contentblob.go b/x-pack/filebeat/input/o365audit/contentblob.go
index 598ca5f8b9a..55283aaa39c 100644
--- a/x-pack/filebeat/input/o365audit/contentblob.go
+++ b/x-pack/filebeat/input/o365audit/contentblob.go
@@ -6,12 +6,12 @@ package o365audit
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
 
 	"github.com/Azure/go-autorest/autorest"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/o365audit/poll"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -53,13 +53,13 @@ func (c contentBlob) OnResponse(response *http.Response) (actions []poll.Action)
 	}
 	var raws []json.RawMessage
 	if err := readJSONBody(response, &raws); err != nil {
-		return append(actions, poll.Terminate(errors.Wrap(err, "reading body failed")))
+		return append(actions, poll.Terminate(fmt.Errorf("reading body failed: %w", err)))
 	}
 	entries := make([]mapstr.M, len(raws))
 	for idx, raw := range raws {
 		var entry mapstr.M
 		if err := json.Unmarshal(raw, &entry); err != nil {
-			return append(actions, poll.Terminate(errors.Wrap(err, "decoding json failed")))
+			return append(actions, poll.Terminate(fmt.Errorf("decoding json failed: %w", err)))
 		}
 		entries[idx] = entry
 		id, _ := getString(entry, "Id")
diff --git a/x-pack/filebeat/input/o365audit/contentblob_test.go b/x-pack/filebeat/input/o365audit/contentblob_test.go
index 223c2aa971a..1a71595d7e9 100644
--- a/x-pack/filebeat/input/o365audit/contentblob_test.go
+++ b/x-pack/filebeat/input/o365audit/contentblob_test.go
@@ -5,10 +5,10 @@
 package o365audit
 
 import (
+	"errors"
 	"testing"
 	"time"
 
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 
 	"github.com/elastic/beats/v7/libbeat/beat"
diff --git a/x-pack/filebeat/input/o365audit/dates.go b/x-pack/filebeat/input/o365audit/dates.go
index ff6eb5db989..6e6c99c80ec 100644
--- a/x-pack/filebeat/input/o365audit/dates.go
+++ b/x-pack/filebeat/input/o365audit/dates.go
@@ -5,11 +5,10 @@
 package o365audit
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/mapstr"
 )
 
diff --git a/x-pack/filebeat/input/o365audit/input.go b/x-pack/filebeat/input/o365audit/input.go
index cf92f1a4f46..3793ce43d6a 100644
--- a/x-pack/filebeat/input/o365audit/input.go
+++ b/x-pack/filebeat/input/o365audit/input.go
@@ -7,11 +7,11 @@ package o365audit
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"time"
 
 	"github.com/Azure/go-autorest/autorest"
 	"github.com/joeshaw/multierror"
-	"github.com/pkg/errors"
 
 	v2 "github.com/elastic/beats/v7/filebeat/input/v2"
 	cursor "github.com/elastic/beats/v7/filebeat/input/v2/input-cursor"
@@ -70,7 +70,7 @@ func Plugin(log *logp.Logger, store cursor.StateStore) v2.Plugin {
 func configure(cfg *conf.C) ([]cursor.Source, cursor.Input, error) {
 	config := defaultConfig()
 	if err := cfg.Unpack(&config); err != nil {
-		return nil, nil, errors.Wrap(err, "reading config")
+		return nil, nil, fmt.Errorf("reading config: %w", err)
 	}
 
 	var sources []cursor.Source
@@ -100,7 +100,7 @@ func (inp *o365input) Test(src cursor.Source, ctx v2.TestContext) error {
 	}
 
 	if _, err := auth.Token(); err != nil {
-		return errors.Wrapf(err, "unable to acquire authentication token for tenant:%s", tenantID)
+		return fmt.Errorf("unable to acquire authentication token for tenant:%s: %w", tenantID, err)
 	}
 
 	return nil
@@ -150,7 +150,7 @@ func (inp *o365input) runOnce(
 	}
 
 	if _, err := tokenProvider.Token(); err != nil {
-		return errors.Wrapf(err, "unable to acquire authentication token for tenant:%s", stream.tenantID)
+		return fmt.Errorf("unable to acquire authentication token for tenant:%s: %w", stream.tenantID, err)
 	}
 
 	config := &inp.config
@@ -171,7 +171,7 @@ func (inp *o365input) runOnce(
 		),
 	)
 	if err != nil {
-		return errors.Wrap(err, "failed to create API poller")
+		return fmt.Errorf("failed to create API poller: %w", err)
 	}
 
 	start := initCheckpoint(log, cursor, config.API.MaxRetention)
@@ -243,7 +243,7 @@ func (env apiEnvironment) toBeatEvent(raw json.RawMessage, doc mapstr.M) beat.Ev
 	ts, err := getDateKey(doc, "CreationTime", apiDateFormats)
 	if err != nil {
 		ts = time.Now()
-		errs = append(errs, errors.Wrap(err, "failed parsing CreationTime"))
+		errs = append(errs, fmt.Errorf("failed parsing CreationTime: %w", err))
 	}
 	b := beat.Event{
 		Timestamp: ts,
diff --git a/x-pack/filebeat/input/o365audit/listblobs.go b/x-pack/filebeat/input/o365audit/listblobs.go
index ebdbddf79f6..58437b9f614 100644
--- a/x-pack/filebeat/input/o365audit/listblobs.go
+++ b/x-pack/filebeat/input/o365audit/listblobs.go
@@ -6,6 +6,7 @@ package o365audit
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -13,7 +14,6 @@ import (
 	"time"
 
 	"github.com/Azure/go-autorest/autorest"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/o365audit/poll"
 )
@@ -280,10 +280,10 @@ func readJSONBody(response *http.Response, dest interface{}) error {
 		autorest.ByClosing())
 	body, err := ioutil.ReadAll(response.Body)
 	if err != nil {
-		return errors.Wrap(err, "reading body failed")
+		return fmt.Errorf("reading body failed: %w", err)
 	}
 	if err = json.Unmarshal(body, dest); err != nil {
-		return errors.Wrap(err, "decoding json failed")
+		return fmt.Errorf("decoding json failed: %w", err)
 	}
 	return nil
 }
diff --git a/x-pack/filebeat/input/o365audit/poll/poll.go b/x-pack/filebeat/input/o365audit/poll/poll.go
index d32ea4ec135..3f616d433b3 100644
--- a/x-pack/filebeat/input/o365audit/poll/poll.go
+++ b/x-pack/filebeat/input/o365audit/poll/poll.go
@@ -6,12 +6,12 @@ package poll
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
 
 	"github.com/Azure/go-autorest/autorest"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/beats/v7/x-pack/filebeat/input/o365audit/auth"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -90,14 +90,14 @@ func (r *Poller) fetchWithDelay(item Transaction, minDelay time.Duration) error
 	if r.tp != nil {
 		token, err := r.tp.Token()
 		if err != nil {
-			return errors.Wrap(err, "failed getting a token")
+			return fmt.Errorf("failed getting a token: %w", err)
 		}
 		decorators = append(decorators, autorest.WithBearerAuthorization(token))
 	}
 
 	request, err := autorest.Prepare(&http.Request{}, decorators...)
 	if err != nil {
-		return errors.Wrap(err, "failed preparing request")
+		return fmt.Errorf("failed preparing request: %w", err)
 	}
 	delay := max(item.Delay(), minDelay)
 	r.log.Debugf(" -- wait %s for %s", delay, request.URL.String())
@@ -115,7 +115,7 @@ func (r *Poller) fetchWithDelay(item Transaction, minDelay time.Duration) error
 
 	for _, act := range acts {
 		if err = act(r); err != nil {
-			return errors.Wrapf(err, "error acting on %+v", act)
+			return fmt.Errorf("error acting on %+v: %w", act, err)
 		}
 	}
 
@@ -242,7 +242,7 @@ func Terminate(err error) Action {
 		if err == nil {
 			return errors.New("polling terminated without a specific error")
 		}
-		return errors.Wrap(err, "polling terminated due to error")
+		return fmt.Errorf("polling terminated due to error: %w", err)
 	}
 }
 
diff --git a/x-pack/filebeat/module/cisco/shared/gen-ecs-mapping-docs.go b/x-pack/filebeat/module/cisco/shared/gen-ecs-mapping-docs.go
index 929a2b9dfb9..f4f6ccb34b5 100644
--- a/x-pack/filebeat/module/cisco/shared/gen-ecs-mapping-docs.go
+++ b/x-pack/filebeat/module/cisco/shared/gen-ecs-mapping-docs.go
@@ -8,13 +8,12 @@ package main
 
 import (
 	"encoding/csv"
+	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"os"
 	"sort"
-
-	"github.com/pkg/errors"
 )
 
 var outputFile = flag.String("output", "ftd-ecs-mappings.asciidoc", "Output file")
@@ -114,7 +113,7 @@ func loadMappings(reader io.Reader) (m idMappings, err error) {
 			break
 		}
 		if err != nil {
-			return m, errors.Wrapf(err, "failed reading line %d", lineNum)
+			return m, fmt.Errorf("failed reading line %d: %w", lineNum, err)
 		}
 		if len(record) < 3 {
 			return m, fmt.Errorf("line %d has unexpected number of columns: %d", lineNum, len(record))
diff --git a/x-pack/filebeat/module/cisco/shared/gen-ftd-ecs-mapping.go b/x-pack/filebeat/module/cisco/shared/gen-ftd-ecs-mapping.go
index 6ad9a255212..8ce78bbf1df 100644
--- a/x-pack/filebeat/module/cisco/shared/gen-ftd-ecs-mapping.go
+++ b/x-pack/filebeat/module/cisco/shared/gen-ftd-ecs-mapping.go
@@ -8,6 +8,7 @@ package main
 
 import (
 	"encoding/csv"
+	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -16,8 +17,6 @@ import (
 	"unicode"
 
 	"gopkg.in/yaml.v2"
-
-	"github.com/pkg/errors"
 )
 
 var (
@@ -142,7 +141,7 @@ func generate() error {
 	content = append(content, end...)
 	n, err := outHandle.Write(content)
 	if err != nil {
-		return errors.Wrap(err, "failed writing output file")
+		return fmt.Errorf("failed writing output file: %w", err)
 	}
 	if n != len(content) {
 		return fmt.Errorf("short write on output file. expected=%d, written=%d", len(content), n)
@@ -160,7 +159,7 @@ func loadMappings(reader io.Reader) (m mappings, err error) {
 			break
 		}
 		if err != nil {
-			return m, errors.Wrapf(err, "failed reading line %d", lineNum)
+			return m, fmt.Errorf("failed reading line %d: %w", lineNum, err)
 		}
 		if len(record) < 3 {
 			return m, fmt.Errorf("line %d has unexpected number of columns: %d", lineNum, len(record))
diff --git a/x-pack/functionbeat/function/provider/provider.go b/x-pack/functionbeat/function/provider/provider.go
index f3b4d56bd8a..6c33eb80b1a 100644
--- a/x-pack/functionbeat/function/provider/provider.go
+++ b/x-pack/functionbeat/function/provider/provider.go
@@ -8,8 +8,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/feature"
 	"github.com/elastic/beats/v7/libbeat/publisher/pipeline"
 	"github.com/elastic/beats/v7/x-pack/functionbeat/function/core"
@@ -51,7 +49,7 @@ type Runnable struct {
 func (r *Runnable) Run(ctx context.Context, t telemetry.T) error {
 	client, err := r.makeClient(r.config)
 	if err != nil {
-		return errors.Wrap(err, "could not create a client for the function")
+		return fmt.Errorf("could not create a client for the function: %w", err)
 	}
 	defer client.Close()
 	return r.function.Run(ctx, client, t)
diff --git a/x-pack/functionbeat/function/provider/provider_test.go b/x-pack/functionbeat/function/provider/provider_test.go
index e68eb9f57a4..47385cbb029 100644
--- a/x-pack/functionbeat/function/provider/provider_test.go
+++ b/x-pack/functionbeat/function/provider/provider_test.go
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"testing"
 
-	e "github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 
 	"github.com/elastic/beats/v7/libbeat/beat"
@@ -47,7 +46,7 @@ func TestRunnable(t *testing.T) {
 		}
 
 		errReceived := runnable.Run(context.Background(), telemetry.Ignored())
-		assert.Equal(t, err, e.Cause(errReceived))
+		assert.Equal(t, "could not create a client for the function: "+err.Error(), errReceived.Error())
 	})
 
 	t.Run("propagate functions errors to the coordinator", func(t *testing.T) {
@@ -59,7 +58,7 @@ func TestRunnable(t *testing.T) {
 		}
 
 		errReceived := runnable.Run(context.Background(), telemetry.Ignored())
-		assert.Equal(t, err, e.Cause(errReceived))
+		assert.Equal(t, err.Error(), errReceived.Error())
 	})
 
 	t.Run("when there is no error run and exit normaly", func(t *testing.T) {
diff --git a/x-pack/functionbeat/manager/core/makezip.go b/x-pack/functionbeat/manager/core/makezip.go
index aa311db9c34..6f5c2c2d530 100644
--- a/x-pack/functionbeat/manager/core/makezip.go
+++ b/x-pack/functionbeat/manager/core/makezip.go
@@ -9,8 +9,6 @@ import (
 
 	yaml "gopkg.in/yaml.v2"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/libbeat/cfgfile"
 	"github.com/elastic/beats/v7/libbeat/cmd/instance"
 	"github.com/elastic/beats/v7/x-pack/functionbeat/config"
@@ -105,7 +103,7 @@ func keystorePackager() (keystore.Packager, error) {
 
 	store, err := instance.LoadKeystore(cfg, "functionbeat")
 	if err != nil {
-		return nil, errors.Wrapf(err, "cannot load the keystore for packaging")
+		return nil, fmt.Errorf("cannot load the keystore for packaging: %w", err)
 	}
 
 	packager, ok := store.(keystore.Packager)
diff --git a/x-pack/libbeat/autodiscover/providers/aws/ec2/watch.go b/x-pack/libbeat/autodiscover/providers/aws/ec2/watch.go
index 967833895bd..decc8159868 100644
--- a/x-pack/libbeat/autodiscover/providers/aws/ec2/watch.go
+++ b/x-pack/libbeat/autodiscover/providers/aws/ec2/watch.go
@@ -6,10 +6,9 @@ package ec2
 
 import (
 	"context"
+	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-
 	awsauto "github.com/elastic/beats/v7/x-pack/libbeat/autodiscover/providers/aws"
 	"github.com/elastic/elastic-agent-libs/logp"
 )
@@ -61,7 +60,7 @@ func (w *watcher) forever() {
 		case <-w.ticker.C:
 			err := w.once()
 			if err != nil {
-				logp.Error(errors.Wrap(err, "error while fetching AWS EC2s"))
+				logp.Error(fmt.Errorf("error while fetching AWS EC2s: %w", err))
 			}
 		}
 	}
diff --git a/x-pack/libbeat/autodiscover/providers/aws/elb/provider_test.go b/x-pack/libbeat/autodiscover/providers/aws/elb/provider_test.go
index 9d050765781..688323e26f2 100644
--- a/x-pack/libbeat/autodiscover/providers/aws/elb/provider_test.go
+++ b/x-pack/libbeat/autodiscover/providers/aws/elb/provider_test.go
@@ -5,12 +5,12 @@
 package elb
 
 import (
+	"errors"
 	"sync"
 	"testing"
 	"time"
 
 	"github.com/gofrs/uuid"
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
diff --git a/x-pack/libbeat/common/cloudfoundry/doer.go b/x-pack/libbeat/common/cloudfoundry/doer.go
index 21bd7edaeb8..f1e3218b71b 100644
--- a/x-pack/libbeat/common/cloudfoundry/doer.go
+++ b/x-pack/libbeat/common/cloudfoundry/doer.go
@@ -12,8 +12,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/elastic-agent-libs/logp"
 )
 
@@ -44,7 +42,7 @@ func (d *authTokenDoer) Do(r *http.Request) (*http.Response, error) {
 		// The reason for writing an error here is that pushing the error upstream
 		// is handled by loggregate library, which is beyond our reach.
 		d.log.Errorf("error creating UAA Auth Token: %+v", err)
-		return nil, errors.Wrap(err, "error retrieving UUA token")
+		return nil, fmt.Errorf("error retrieving UUA token: %w", err)
 	}
 	r.Header.Set("Authorization", t)
 	return d.httpClient.Do(r)
diff --git a/x-pack/libbeat/common/cloudfoundry/hub.go b/x-pack/libbeat/common/cloudfoundry/hub.go
index e6ab4ce76ca..07f1000e533 100644
--- a/x-pack/libbeat/common/cloudfoundry/hub.go
+++ b/x-pack/libbeat/common/cloudfoundry/hub.go
@@ -5,11 +5,11 @@
 package cloudfoundry
 
 import (
+	"fmt"
 	"net/http"
 	"strings"
 
 	"github.com/cloudfoundry-community/go-cfclient"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/elastic-agent-libs/logp"
 	"github.com/elastic/elastic-agent-libs/transport/httpcommon"
@@ -68,7 +68,7 @@ func (h *Hub) Client() (*cfclient.Client, error) {
 		UserAgent:         h.userAgent,
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating cloudfoundry client")
+		return nil, fmt.Errorf("error creating cloudfoundry client: %w", err)
 	}
 	if h.cfg.DopplerAddress != "" {
 		cf.Endpoint.DopplerEndpoint = h.cfg.DopplerAddress
@@ -131,7 +131,7 @@ func (h *Hub) DopplerConsumerFromClient(client *cfclient.Client, callbacks Doppl
 	}
 	tlsConfig, err := tlscommon.LoadTLSConfig(h.cfg.Transport.TLS)
 	if err != nil {
-		return nil, errors.Wrap(err, "loading tls config")
+		return nil, fmt.Errorf("loading tls config: %w", err)
 	}
 	proxy := h.cfg.Transport.Proxy.ProxyFunc()
 
diff --git a/x-pack/metricbeat/module/azure/app_insights/app_insights.go b/x-pack/metricbeat/module/azure/app_insights/app_insights.go
index 6790810e2a2..637251be54f 100644
--- a/x-pack/metricbeat/module/azure/app_insights/app_insights.go
+++ b/x-pack/metricbeat/module/azure/app_insights/app_insights.go
@@ -5,10 +5,9 @@
 package app_insights
 
 import (
+	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb/parse"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -56,7 +55,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 	}
 	client, err := NewClient(config)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error initializing the monitor client: module azure - %s metricset", metricsetName)
+		return nil, fmt.Errorf("error initializing the monitor client: module azure - %s metricset: %w", metricsetName, err)
 	}
 	return &MetricSet{
 		BaseMetricSet: base,
@@ -69,7 +68,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	results, err := m.client.GetMetricValues()
 	if err != nil {
-		return errors.Wrap(err, "error retrieving metric values")
+		return fmt.Errorf("error retrieving metric values: %w", err)
 	}
 	events := EventsMapping(results, m.client.Config.ApplicationId, m.client.Config.Namespace)
 	for _, event := range events {
diff --git a/x-pack/metricbeat/module/azure/app_insights/client.go b/x-pack/metricbeat/module/azure/app_insights/client.go
index 2efdf57ccea..d2bed8fbf0e 100644
--- a/x-pack/metricbeat/module/azure/app_insights/client.go
+++ b/x-pack/metricbeat/module/azure/app_insights/client.go
@@ -11,7 +11,6 @@ import (
 	"github.com/gofrs/uuid"
 
 	"github.com/Azure/azure-sdk-for-go/services/preview/appinsights/v1/insights"
-	"github.com/pkg/errors"
 
 	"github.com/elastic/elastic-agent-libs/logp"
 )
@@ -62,7 +61,7 @@ func (client *Client) GetMetricValues() (insights.ListMetricsResultsItem, error)
 			}
 			id, err := uuid.NewV4()
 			if err != nil {
-				return result, errors.Wrap(err, "could not generate identifier in client")
+				return result, fmt.Errorf("could not generate identifier in client: %w", err)
 			}
 			strId := id.String()
 			bodyMetrics = append(bodyMetrics, insights.MetricsPostBodySchema{ID: &strId, Parameters: &bodyMetric})
@@ -72,7 +71,7 @@ func (client *Client) GetMetricValues() (insights.ListMetricsResultsItem, error)
 	if err == nil {
 		return result, nil
 	}
-	return result, errors.Wrap(err, "could not retrieve app insights metrics from service")
+	return result, fmt.Errorf("could not retrieve app insights metrics from service: %w", err)
 }
 
 func calculateTimespan(duration time.Duration) *string {
diff --git a/x-pack/metricbeat/module/azure/app_insights/client_test.go b/x-pack/metricbeat/module/azure/app_insights/client_test.go
index ca62e9a82d2..4763c28da20 100644
--- a/x-pack/metricbeat/module/azure/app_insights/client_test.go
+++ b/x-pack/metricbeat/module/azure/app_insights/client_test.go
@@ -5,10 +5,10 @@
 package app_insights
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/Azure/azure-sdk-for-go/services/preview/appinsights/v1/insights"
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
diff --git a/x-pack/metricbeat/module/azure/azure.go b/x-pack/metricbeat/module/azure/azure.go
index 38db7f7c6d7..aa26a0c5705 100644
--- a/x-pack/metricbeat/module/azure/azure.go
+++ b/x-pack/metricbeat/module/azure/azure.go
@@ -7,8 +7,6 @@ package azure
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 )
 
@@ -41,7 +39,7 @@ func NewMetricSet(base mb.BaseMetricSet) (*MetricSet, error) {
 	var config Config
 	err := base.Module().UnpackConfig(&config)
 	if err != nil {
-		return nil, errors.Wrap(err, "error unpack raw module config using UnpackConfig")
+		return nil, fmt.Errorf("error unpack raw module config using UnpackConfig: %w", err)
 	}
 
 	//validate config based on metricset
@@ -49,13 +47,13 @@ func NewMetricSet(base mb.BaseMetricSet) (*MetricSet, error) {
 	case nativeMetricset:
 		// resources must be configured for the monitor metricset
 		if len(config.Resources) == 0 {
-			return nil, errors.Errorf("no resource options defined: module azure - %s metricset", metricsetName)
+			return nil, fmt.Errorf("no resource options defined: module azure - %s metricset", metricsetName)
 		}
 	default:
 		// validate config resource options entered, no resource queries allowed for the compute_vm and compute_vm_scaleset metricsets
 		for _, resource := range config.Resources {
 			if resource.Query != "" {
-				return nil, errors.Errorf("error initializing the monitor client: module azure - %s metricset. No queries allowed, please select one of the allowed options", metricsetName)
+				return nil, fmt.Errorf("error initializing the monitor client: module azure - %s metricset. No queries allowed, please select one of the allowed options", metricsetName)
 			}
 		}
 		// check for lightweight resources if no groups or ids have been entered, if not a new resource is created to check the entire subscription
@@ -77,7 +75,7 @@ func NewMetricSet(base mb.BaseMetricSet) (*MetricSet, error) {
 	// instantiate monitor client
 	monitorClient, err := NewClient(config)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error initializing the monitor client: module azure - %s metricset", metricsetName)
+		return nil, fmt.Errorf("error initializing the monitor client: module azure - %s metricset: %w", metricsetName, err)
 	}
 	return &MetricSet{
 		BaseMetricSet: base,
@@ -104,7 +102,7 @@ func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 		results := m.Client.GetMetricValues(metrics, report)
 		err := EventsMapping(results, m.Client, report)
 		if err != nil {
-			return errors.Wrap(err, "error running EventsMapping")
+			return fmt.Errorf("error running EventsMapping: %w", err)
 		}
 	}
 	return nil
diff --git a/x-pack/metricbeat/module/enterprisesearch/health/data.go b/x-pack/metricbeat/module/enterprisesearch/health/data.go
index c2620bff247..318f9fa0598 100644
--- a/x-pack/metricbeat/module/enterprisesearch/health/data.go
+++ b/x-pack/metricbeat/module/enterprisesearch/health/data.go
@@ -6,9 +6,10 @@ package health
 
 import (
 	"encoding/json"
+	"errors"
+	"fmt"
 
 	"github.com/joeshaw/multierror"
-	"github.com/pkg/errors"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -125,7 +126,7 @@ func eventMapping(report mb.ReporterV2, input []byte, isXpack bool) error {
 
 	event.MetricSetFields, err = schema.Apply(data)
 	if err != nil {
-		errs = append(errs, errors.Wrap(err, "failure to apply health schema"))
+		errs = append(errs, fmt.Errorf("failure to apply health schema: %w", err))
 	} else {
 		report.Event(event)
 	}
diff --git a/x-pack/metricbeat/module/enterprisesearch/health/health.go b/x-pack/metricbeat/module/enterprisesearch/health/health.go
index d263314bf95..a8de3c90bc3 100644
--- a/x-pack/metricbeat/module/enterprisesearch/health/health.go
+++ b/x-pack/metricbeat/module/enterprisesearch/health/health.go
@@ -5,7 +5,7 @@
 package health
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/helper"
@@ -71,12 +71,12 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 
 	err = eventMapping(report, content, m.XPackEnabled)
 	if err != nil {
-		return errors.Wrap(err, "error converting event")
+		return fmt.Errorf("error converting event: %w", err)
 	}
 
 	return nil
diff --git a/x-pack/metricbeat/module/enterprisesearch/stats/data.go b/x-pack/metricbeat/module/enterprisesearch/stats/data.go
index ea20ded1745..cd1ebd13dc3 100644
--- a/x-pack/metricbeat/module/enterprisesearch/stats/data.go
+++ b/x-pack/metricbeat/module/enterprisesearch/stats/data.go
@@ -6,9 +6,10 @@ package stats
 
 import (
 	"encoding/json"
+	"errors"
+	"fmt"
 
 	"github.com/joeshaw/multierror"
-	"github.com/pkg/errors"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -195,7 +196,7 @@ func eventMapping(report mb.ReporterV2, input []byte, isXpack bool) error {
 
 	event.MetricSetFields, err = schema.Apply(data)
 	if err != nil {
-		errs = append(errs, errors.Wrap(err, "failure to apply stats schema"))
+		errs = append(errs, fmt.Errorf("failure to apply stats schema: %w", err))
 	} else {
 		report.Event(event)
 	}
diff --git a/x-pack/metricbeat/module/enterprisesearch/stats/stats.go b/x-pack/metricbeat/module/enterprisesearch/stats/stats.go
index c59b3481af4..234a65d0d11 100644
--- a/x-pack/metricbeat/module/enterprisesearch/stats/stats.go
+++ b/x-pack/metricbeat/module/enterprisesearch/stats/stats.go
@@ -5,7 +5,7 @@
 package stats
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/libbeat/common/cfgwarn"
 	"github.com/elastic/beats/v7/metricbeat/helper"
@@ -71,12 +71,12 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(report mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 
 	err = eventMapping(report, content, m.XPackEnabled)
 	if err != nil {
-		return errors.Wrap(err, "error converting event")
+		return fmt.Errorf("error converting event: %w", err)
 	}
 
 	return nil
diff --git a/x-pack/metricbeat/module/iis/application_pool/reader.go b/x-pack/metricbeat/module/iis/application_pool/reader.go
index 4ce1f240381..77d377a75d6 100644
--- a/x-pack/metricbeat/module/iis/application_pool/reader.go
+++ b/x-pack/metricbeat/module/iis/application_pool/reader.go
@@ -7,14 +7,13 @@
 package application_pool
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/elastic/beats/v7/metricbeat/helper/windows/pdh"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 	"github.com/elastic/go-sysinfo"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/elastic-agent-libs/logp"
 )
@@ -77,7 +76,7 @@ func newReader(config Config) (*Reader, error) {
 
 	err := r.initAppPools()
 	if err != nil {
-		return nil, errors.Wrap(err, "error loading counters for existing app pools")
+		return nil, fmt.Errorf("error loading counters for existing app pools: %w", err)
 	}
 	return r, nil
 }
@@ -86,7 +85,7 @@ func newReader(config Config) (*Reader, error) {
 func (r *Reader) initAppPools() error {
 	apps, err := getApplicationPools(r.config.Names)
 	if err != nil {
-		return errors.Wrap(err, "failed retrieving running worker processes")
+		return fmt.Errorf("failed retrieving running worker processes: %w", err)
 	}
 	r.applicationPools = apps
 	if len(apps) == 0 {
@@ -116,14 +115,14 @@ func (r *Reader) initAppPools() error {
 		}
 		for _, v := range childQueries {
 			if err := r.query.AddCounter(v, "", "float", len(childQueries) > 1); err != nil {
-				return errors.Wrapf(err, `failed to add counter (query="%v")`, v)
+				return fmt.Errorf(`failed to add counter (query="%v"): %w`, v, err)
 			}
 			r.workerProcesses[v] = key
 		}
 	}
 	err = r.query.RemoveUnusedCounters(newQueries)
 	if err != nil {
-		return errors.Wrap(err, "failed removing unused counter values")
+		return fmt.Errorf("failed removing unused counter values: %w", err)
 	}
 	return nil
 }
@@ -138,14 +137,14 @@ func (r *Reader) read() ([]mb.Event, error) {
 	// Some counters, such as rate counters, require two counter values in order to compute a displayable value. In this case we must call PdhCollectQueryData twice before calling PdhGetFormattedCounterValue.
 	// For more information, see Collecting Performance Data (https://docs.microsoft.com/en-us/windows/desktop/PerfCtrs/collecting-performance-data).
 	if err := r.query.CollectData(); err != nil {
-		return nil, errors.Wrap(err, "failed querying counter values")
+		return nil, fmt.Errorf("failed querying counter values: %w", err)
 	}
 
 	// Get the values.
 	values, err := r.query.GetFormattedCounterValues()
 	if err != nil {
 		r.close()
-		return nil, errors.Wrap(err, "failed formatting counter values")
+		return nil, fmt.Errorf("failed formatting counter values: %w", err)
 	}
 	var events []mb.Event
 	eventGroup := r.mapEvents(values)
diff --git a/x-pack/metricbeat/module/iis/test/integration.go b/x-pack/metricbeat/module/iis/test/integration.go
index ede53c9406f..525bc3c1003 100644
--- a/x-pack/metricbeat/module/iis/test/integration.go
+++ b/x-pack/metricbeat/module/iis/test/integration.go
@@ -8,8 +8,10 @@
 package test
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/StackExchange/wmi"
-	"github.com/pkg/errors"
 )
 
 // Service struct used to map Win32_Service
@@ -37,7 +39,7 @@ func EnsureIISIsRunning() error {
 		return errors.New("IIS is not not installed")
 	}
 	if ser[0].State != "Running" {
-		return errors.Errorf("IIS is installed but status is %s", ser[0].State)
+		return fmt.Errorf("IIS is installed but status is %s", ser[0].State)
 	}
 	return nil
 }
diff --git a/x-pack/metricbeat/module/mssql/connection.go b/x-pack/metricbeat/module/mssql/connection.go
index fa4c0fa36ae..ac328491ddb 100644
--- a/x-pack/metricbeat/module/mssql/connection.go
+++ b/x-pack/metricbeat/module/mssql/connection.go
@@ -6,24 +6,23 @@ package mssql
 
 import (
 	"database/sql"
+	"fmt"
 
 	// Register driver.
 	_ "github.com/denisenkom/go-mssqldb"
-
-	"github.com/pkg/errors"
 )
 
 // NewConnection returns a connection already established with MSSQL
 func NewConnection(uri string) (*sql.DB, error) {
 	db, err := sql.Open("sqlserver", uri)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not create db instance")
+		return nil, fmt.Errorf("could not create db instance: %w", err)
 	}
 
 	// Check the connection before executing all queries to reduce the number
 	// of connection errors that we might encounter.
 	if err = db.Ping(); err != nil {
-		err = errors.Wrap(err, "error doing ping to db")
+		err = fmt.Errorf("error doing ping to db: %w", err)
 	}
 
 	return db, err
diff --git a/x-pack/metricbeat/module/mssql/performance/data_integration_test.go b/x-pack/metricbeat/module/mssql/performance/data_integration_test.go
index 498fdc1d0de..0d3d1d8fc78 100644
--- a/x-pack/metricbeat/module/mssql/performance/data_integration_test.go
+++ b/x-pack/metricbeat/module/mssql/performance/data_integration_test.go
@@ -5,11 +5,11 @@
 package performance
 
 import (
+	"errors"
 	"net/url"
 	"testing"
 
 	_ "github.com/denisenkom/go-mssqldb"
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 
 	mbtest "github.com/elastic/beats/v7/metricbeat/mb/testing"
diff --git a/x-pack/metricbeat/module/mssql/transaction_log/transaction_log.go b/x-pack/metricbeat/module/mssql/transaction_log/transaction_log.go
index 2fb7c43e0d2..821b5db5d08 100644
--- a/x-pack/metricbeat/module/mssql/transaction_log/transaction_log.go
+++ b/x-pack/metricbeat/module/mssql/transaction_log/transaction_log.go
@@ -8,8 +8,6 @@ import (
 	"database/sql"
 	"fmt"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 	"github.com/elastic/beats/v7/x-pack/metricbeat/module/mssql"
 	"github.com/elastic/elastic-agent-libs/logp"
@@ -58,7 +56,7 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 
 	db, err := mssql.NewConnection(base.HostData().URI)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not create connection to db")
+		return nil, fmt.Errorf("could not create connection to db: %w", err)
 	}
 
 	return &MetricSet{
@@ -131,7 +129,7 @@ func (m *MetricSet) getLogSpaceUsageForDb(dbName string) (mapstr.M, error) {
 		&res.logSpaceInBytesSinceLastBackup); err != nil {
 		// Because this query only returns a single result an error in the first scan is
 		// probably a "data returned but not properly scanned"
-		err = errors.Wrap(err, "error scanning single result")
+		err = fmt.Errorf("error scanning single result: %w", err)
 		return nil, err
 	}
 
@@ -156,7 +154,7 @@ func (m *MetricSet) getLogStats(db dbInfo) (mapstr.M, error) {
 	if err := row.Scan(&res.databaseID, &res.sizeMB, &res.activeSizeMB, &res.backupTime, &res.sinceLastBackupMB, &res.sinceLastCheckpointMB, &res.recoverySizeMB); err != nil {
 		// Because this query only returns a single result an error in the first scan is
 		// probably a "data returned but not properly scanned"
-		err = errors.Wrap(err, "error scanning single result")
+		err = fmt.Errorf("error scanning single result: %w", err)
 		return nil, err
 	}
 
@@ -189,14 +187,14 @@ func (m *MetricSet) getDbsNames() ([]dbInfo, error) {
 	var rows *sql.Rows
 	rows, err := m.db.Query("SELECT name, database_id FROM sys.databases")
 	if err != nil {
-		return nil, errors.Wrap(err, "error doing query 'SELECT name, database_id FROM sys.databases'")
+		return nil, fmt.Errorf("error doing query 'SELECT name, database_id FROM sys.databases': %w", err)
 	}
 	defer closeRows(rows)
 
 	for rows.Next() {
 		var row dbInfo
 		if err = rows.Scan(&row.name, &row.id); err != nil {
-			return nil, errors.Wrap(err, "error scanning row results")
+			return nil, fmt.Errorf("error scanning row results: %w", err)
 		}
 
 		res = append(res, row)
diff --git a/x-pack/metricbeat/module/oracle/performance/buffer_cache_hit_ratio.go b/x-pack/metricbeat/module/oracle/performance/buffer_cache_hit_ratio.go
index 0b0fb8ad41c..fc0db9d7859 100644
--- a/x-pack/metricbeat/module/oracle/performance/buffer_cache_hit_ratio.go
+++ b/x-pack/metricbeat/module/oracle/performance/buffer_cache_hit_ratio.go
@@ -7,8 +7,7 @@ package performance
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/x-pack/metricbeat/module/oracle"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -35,7 +34,7 @@ func (e *performanceExtractor) bufferCacheHitRatio(ctx context.Context) ([]buffe
        1 - (physical_reads / (db_block_gets + consistent_gets)) "Hit Ratio"
 FROM V$BUFFER_POOL_STATISTICS`)
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing query")
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	results := make([]bufferCacheHitRatio, 0)
diff --git a/x-pack/metricbeat/module/oracle/performance/cursors.go b/x-pack/metricbeat/module/oracle/performance/cursors.go
index ebc5a1df61d..d29b16b7815 100644
--- a/x-pack/metricbeat/module/oracle/performance/cursors.go
+++ b/x-pack/metricbeat/module/oracle/performance/cursors.go
@@ -7,8 +7,7 @@ package performance
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/x-pack/metricbeat/module/oracle"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -56,7 +55,7 @@ func (e *performanceExtractor) cursorsByUsernameAndMachine(ctx context.Context)
 						 s.machine
 		ORDER BY 1 DESC`)
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing query")
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	results := make([]cursorsByUsernameAndMachine, 0)
diff --git a/x-pack/metricbeat/module/oracle/performance/data.go b/x-pack/metricbeat/module/oracle/performance/data.go
index f24bfd86969..1004fac720a 100644
--- a/x-pack/metricbeat/module/oracle/performance/data.go
+++ b/x-pack/metricbeat/module/oracle/performance/data.go
@@ -6,8 +6,7 @@ package performance
 
 import (
 	"context"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/mb"
 )
@@ -17,19 +16,19 @@ func (m *MetricSet) extract(ctx context.Context, extractor performanceExtractMet
 	out = &extractedData{}
 
 	if out.bufferCacheHitRatios, err = extractor.bufferCacheHitRatio(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting buffer cache hit ratio")
+		return nil, fmt.Errorf("error getting buffer cache hit ratio: %w", err)
 	}
 
 	if out.libraryData, err = extractor.libraryCache(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting libraryCache data")
+		return nil, fmt.Errorf("error getting libraryCache data: %w", err)
 	}
 
 	if out.cursorsByUsernameAndMachine, err = extractor.cursorsByUsernameAndMachine(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting cursors by username and machine")
+		return nil, fmt.Errorf("error getting cursors by username and machine: %w", err)
 	}
 
 	if out.totalCursors, err = extractor.totalCursors(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting total cursors")
+		return nil, fmt.Errorf("error getting total cursors: %w", err)
 	}
 
 	return
@@ -40,7 +39,7 @@ func (m *MetricSet) extract(ctx context.Context, extractor performanceExtractMet
 func (m *MetricSet) extractAndTransform(ctx context.Context) ([]mb.Event, error) {
 	extractedMetricsData, err := m.extract(ctx, m.extractor)
 	if err != nil {
-		return nil, errors.Wrap(err, "error extracting data")
+		return nil, fmt.Errorf("error extracting data: %w", err)
 	}
 
 	return m.transform(extractedMetricsData), nil
diff --git a/x-pack/metricbeat/module/oracle/performance/library_cache.go b/x-pack/metricbeat/module/oracle/performance/library_cache.go
index fec3b1b4a7f..fdb7a01abdf 100644
--- a/x-pack/metricbeat/module/oracle/performance/library_cache.go
+++ b/x-pack/metricbeat/module/oracle/performance/library_cache.go
@@ -7,8 +7,7 @@ package performance
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/x-pack/metricbeat/module/oracle"
 	"github.com/elastic/elastic-agent-libs/mapstr"
@@ -36,7 +35,7 @@ func (e *performanceExtractor) libraryCache(ctx context.Context) ([]libraryCache
 		UNION
 		SELECT 'io_reloads' "Ratio", (SUM(reloads) / SUM(pins)) FROM V$LIBRARYCACHE`)
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing query")
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	results := make([]libraryCache, 0)
diff --git a/x-pack/metricbeat/module/oracle/tablespace/data.go b/x-pack/metricbeat/module/oracle/tablespace/data.go
index 526c65e85b7..30c86d766da 100644
--- a/x-pack/metricbeat/module/oracle/tablespace/data.go
+++ b/x-pack/metricbeat/module/oracle/tablespace/data.go
@@ -6,12 +6,11 @@ package tablespace
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/elastic/beats/v7/x-pack/metricbeat/module/oracle"
 	"github.com/elastic/elastic-agent-libs/mapstr"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/mb"
 )
 
@@ -21,15 +20,15 @@ func (m *MetricSet) extract(ctx context.Context, extractor tablespaceExtractMeth
 	out = &extractedData{}
 
 	if out.dataFiles, err = extractor.dataFilesData(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting data_files")
+		return nil, fmt.Errorf("error getting data_files: %w", err)
 	}
 
 	if out.tempFreeSpace, err = extractor.tempFreeSpaceData(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting temp_free_space")
+		return nil, fmt.Errorf("error getting temp_free_space: %w", err)
 	}
 
 	if out.freeSpace, err = extractor.usedAndFreeSpaceData(ctx); err != nil {
-		return nil, errors.Wrap(err, "error getting free space data")
+		return nil, fmt.Errorf("error getting free space data: %w", err)
 	}
 
 	return
@@ -54,7 +53,7 @@ func (m *MetricSet) transform(in *extractedData) (out map[string]mapstr.M) {
 func (m *MetricSet) extractAndTransform(ctx context.Context) ([]mb.Event, error) {
 	extractedMetricsData, err := m.extract(ctx, m.extractor)
 	if err != nil {
-		return nil, errors.Wrap(err, "error extracting data")
+		return nil, fmt.Errorf("error extracting data: %w", err)
 	}
 
 	out := m.transform(extractedMetricsData)
diff --git a/x-pack/metricbeat/module/oracle/tablespace/data_files.go b/x-pack/metricbeat/module/oracle/tablespace/data_files.go
index 73df14b2ca1..be1eba9349d 100644
--- a/x-pack/metricbeat/module/oracle/tablespace/data_files.go
+++ b/x-pack/metricbeat/module/oracle/tablespace/data_files.go
@@ -8,8 +8,6 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-
-	"github.com/pkg/errors"
 )
 
 type dataFile struct {
@@ -34,7 +32,7 @@ func (d *dataFile) eventKey() string {
 func (e *tablespaceExtractor) dataFilesData(ctx context.Context) ([]dataFile, error) {
 	rows, err := e.db.QueryContext(ctx, "SELECT FILE_NAME, FILE_ID, TABLESPACE_NAME, BYTES, STATUS, MAXBYTES, USER_BYTES, ONLINE_STATUS FROM SYS.DBA_DATA_FILES UNION SELECT FILE_NAME, FILE_ID, TABLESPACE_NAME, BYTES, STATUS, MAXBYTES, USER_BYTES, STATUS AS ONLINE_STATUS FROM SYS.DBA_TEMP_FILES")
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing query")
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	results := make([]dataFile, 0)
diff --git a/x-pack/metricbeat/module/oracle/tablespace/mocks_test.go b/x-pack/metricbeat/module/oracle/tablespace/mocks_test.go
index a88b030a29f..12348236bcc 100644
--- a/x-pack/metricbeat/module/oracle/tablespace/mocks_test.go
+++ b/x-pack/metricbeat/module/oracle/tablespace/mocks_test.go
@@ -7,8 +7,7 @@ package tablespace
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"errors"
 )
 
 // happyMockExtractor is a tablespaceExtractMethods implementor that follow and ideal happy path on the entire set of data
diff --git a/x-pack/metricbeat/module/oracle/tablespace/temp_free_space.go b/x-pack/metricbeat/module/oracle/tablespace/temp_free_space.go
index 8bf50e24568..efc8401e2c0 100644
--- a/x-pack/metricbeat/module/oracle/tablespace/temp_free_space.go
+++ b/x-pack/metricbeat/module/oracle/tablespace/temp_free_space.go
@@ -7,8 +7,7 @@ package tablespace
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"fmt"
 )
 
 type tempFreeSpace struct {
@@ -29,7 +28,7 @@ func (d *tempFreeSpace) eventKey() string {
 func (e *tablespaceExtractor) tempFreeSpaceData(ctx context.Context) ([]tempFreeSpace, error) {
 	rows, err := e.db.QueryContext(ctx, "SELECT TABLESPACE_NAME, TABLESPACE_SIZE, ALLOCATED_SPACE, FREE_SPACE FROM DBA_TEMP_FREE_SPACE")
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing query")
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	results := make([]tempFreeSpace, 0)
diff --git a/x-pack/metricbeat/module/oracle/tablespace/used_and_free_space.go b/x-pack/metricbeat/module/oracle/tablespace/used_and_free_space.go
index eec7197dbb4..b17b249808d 100644
--- a/x-pack/metricbeat/module/oracle/tablespace/used_and_free_space.go
+++ b/x-pack/metricbeat/module/oracle/tablespace/used_and_free_space.go
@@ -7,8 +7,7 @@ package tablespace
 import (
 	"context"
 	"database/sql"
-
-	"github.com/pkg/errors"
+	"fmt"
 )
 
 type usedAndFreeSpace struct {
@@ -28,7 +27,7 @@ func (d *usedAndFreeSpace) eventKey() string {
 func (e *tablespaceExtractor) usedAndFreeSpaceData(ctx context.Context) ([]usedAndFreeSpace, error) {
 	rows, err := e.db.QueryContext(ctx, "SELECT b.tablespace_name, tbs_size used, a.free_space free FROM (SELECT tablespace_name, sum(bytes) AS free_space FROM dba_free_space GROUP BY tablespace_name) a, (SELECT tablespace_name, sum(bytes) AS tbs_size FROM dba_data_files GROUP BY tablespace_name) b WHERE a.tablespace_name(+)=b.tablespace_name")
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing query")
+		return nil, fmt.Errorf("error executing query: %w", err)
 	}
 
 	results := make([]usedAndFreeSpace, 0)
diff --git a/x-pack/metricbeat/module/stan/channels/channels.go b/x-pack/metricbeat/module/stan/channels/channels.go
index d2824943ccc..ab3ef50fd9d 100644
--- a/x-pack/metricbeat/module/stan/channels/channels.go
+++ b/x-pack/metricbeat/module/stan/channels/channels.go
@@ -5,7 +5,7 @@
 package channels
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -68,10 +68,10 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) (err error) {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	if err = eventsMapping(content, r); err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/x-pack/metricbeat/module/stan/channels/data.go b/x-pack/metricbeat/module/stan/channels/data.go
index 9ac80ce63d4..25d5d51f392 100644
--- a/x-pack/metricbeat/module/stan/channels/data.go
+++ b/x-pack/metricbeat/module/stan/channels/data.go
@@ -6,8 +6,7 @@ package channels
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -66,12 +65,12 @@ type Channels struct {
 func eventMapping(content map[string]interface{}) (mb.Event, error) {
 	fields, err := channelSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying channels schema")
+		return mb.Event{}, fmt.Errorf("error applying channels schema: %w", err)
 	}
 
 	moduleFields, err := moduleSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying module schema")
+		return mb.Event{}, fmt.Errorf("error applying module schema: %w", err)
 	}
 
 	event := mb.Event{
@@ -85,7 +84,7 @@ func eventMapping(content map[string]interface{}) (mb.Event, error) {
 func eventsMapping(content []byte, r mb.ReporterV2) error {
 	channelsIn := Channels{}
 	if err := json.Unmarshal(content, &channelsIn); err != nil {
-		return errors.Wrap(err, "error unmarshaling Nats streaming channels response to JSON")
+		return fmt.Errorf("error unmarshaling Nats streaming channels response to JSON: %w", err)
 	}
 
 	for _, ch := range channelsIn.Channels {
@@ -109,7 +108,7 @@ func eventsMapping(content []byte, r mb.ReporterV2) error {
 		}
 
 		if evt, err = eventMapping(chWrapper); err != nil {
-			r.Error(errors.Wrap(err, "error mapping channel to its schema"))
+			r.Error(fmt.Errorf("error mapping channel to its schema: %w", err))
 			continue
 		}
 		if !r.Event(evt) {
diff --git a/x-pack/metricbeat/module/stan/stats/data.go b/x-pack/metricbeat/module/stan/stats/data.go
index 569a201f53d..d73549e2655 100644
--- a/x-pack/metricbeat/module/stan/stats/data.go
+++ b/x-pack/metricbeat/module/stan/stats/data.go
@@ -6,8 +6,7 @@ package stats
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -37,17 +36,17 @@ var (
 func eventMapping(content []byte, r mb.ReporterV2) error {
 	var streaming = make(map[string]interface{})
 	if err := json.Unmarshal(content, &streaming); err != nil {
-		return errors.Wrap(err, "error in streaming server mapping")
+		return fmt.Errorf("error in streaming server mapping: %w", err)
 	}
 
 	fields, err := clientsSchema.Apply(streaming)
 	if err != nil {
-		return errors.Wrap(err, "error parsing Nats streaming server API response")
+		return fmt.Errorf("error parsing Nats streaming server API response: %w", err)
 	}
 
 	moduleFields, err := moduleSchema.Apply(streaming)
 	if err != nil {
-		return errors.Wrap(err, "error applying module schema")
+		return fmt.Errorf("error applying module schema: %w", err)
 	}
 	event := mb.Event{
 		MetricSetFields: fields,
diff --git a/x-pack/metricbeat/module/stan/stats/stats.go b/x-pack/metricbeat/module/stan/stats/stats.go
index c83f27cb6e8..05a1c9760e2 100644
--- a/x-pack/metricbeat/module/stan/stats/stats.go
+++ b/x-pack/metricbeat/module/stan/stats/stats.go
@@ -5,7 +5,7 @@
 package stats
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -66,11 +66,11 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) error {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	err = eventMapping(content, r)
 	if err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/x-pack/metricbeat/module/stan/subscriptions/data.go b/x-pack/metricbeat/module/stan/subscriptions/data.go
index 2135c68fca0..16f8c80ecc2 100644
--- a/x-pack/metricbeat/module/stan/subscriptions/data.go
+++ b/x-pack/metricbeat/module/stan/subscriptions/data.go
@@ -6,8 +6,7 @@ package subscriptions
 
 import (
 	"encoding/json"
-
-	"github.com/pkg/errors"
+	"fmt"
 
 	s "github.com/elastic/beats/v7/libbeat/common/schema"
 	c "github.com/elastic/beats/v7/libbeat/common/schema/mapstriface"
@@ -39,12 +38,12 @@ var (
 func eventMapping(content map[string]interface{}) (mb.Event, error) {
 	fields, err := subscriptionsSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying subscription schema")
+		return mb.Event{}, fmt.Errorf("error applying subscription schema: %w", err)
 	}
 
 	moduleFields, err := moduleSchema.Apply(content)
 	if err != nil {
-		return mb.Event{}, errors.Wrap(err, "error applying module schema")
+		return mb.Event{}, fmt.Errorf("error applying module schema: %w", err)
 	}
 
 	event := mb.Event{
@@ -88,7 +87,7 @@ func eventsMapping(content []byte, r mb.ReporterV2) error {
 	var err error
 	channels := Channels{}
 	if err = json.Unmarshal(content, &channels); err != nil {
-		return errors.Wrap(err, "error unmarshaling Nats streaming channels detailed response to JSON")
+		return fmt.Errorf("error unmarshaling Nats streaming channels detailed response to JSON: %w", err)
 	}
 
 	for _, ch := range channels.Channels {
@@ -99,7 +98,7 @@ func eventsMapping(content []byte, r mb.ReporterV2) error {
 			sub["cluster_id"] = channels.ClusterID
 			evt, err = eventMapping(sub)
 			if err != nil {
-				r.Error(errors.Wrap(err, "error mapping subscription event"))
+				r.Error(fmt.Errorf("error mapping subscription event: %w", err))
 				continue
 			}
 
diff --git a/x-pack/metricbeat/module/stan/subscriptions/subscriptions.go b/x-pack/metricbeat/module/stan/subscriptions/subscriptions.go
index 428db923de1..457912b4a5f 100644
--- a/x-pack/metricbeat/module/stan/subscriptions/subscriptions.go
+++ b/x-pack/metricbeat/module/stan/subscriptions/subscriptions.go
@@ -5,7 +5,7 @@
 package subscriptions
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
 
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
@@ -68,10 +68,10 @@ func New(base mb.BaseMetricSet) (mb.MetricSet, error) {
 func (m *MetricSet) Fetch(r mb.ReporterV2) (err error) {
 	content, err := m.http.FetchContent()
 	if err != nil {
-		return errors.Wrap(err, "error in fetch")
+		return fmt.Errorf("error in fetch: %w", err)
 	}
 	if err = eventsMapping(content, r); err != nil {
-		return errors.Wrap(err, "error in mapping")
+		return fmt.Errorf("error in mapping: %w", err)
 	}
 
 	return nil
diff --git a/x-pack/metricbeat/module/syncgateway/syncgateway.go b/x-pack/metricbeat/module/syncgateway/syncgateway.go
index dfd2e16cb84..4d261faa190 100644
--- a/x-pack/metricbeat/module/syncgateway/syncgateway.go
+++ b/x-pack/metricbeat/module/syncgateway/syncgateway.go
@@ -6,11 +6,10 @@ package syncgateway
 
 import (
 	"encoding/json"
+	"fmt"
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/elastic/beats/v7/metricbeat/helper"
 	"github.com/elastic/beats/v7/metricbeat/mb"
 )
@@ -76,7 +75,7 @@ func (m *module) GetSyncgatewayResponse(http *helper.HTTP) (*SgResponse, error)
 
 		input := SgResponse{}
 		if err = json.Unmarshal(byt, &input); err != nil {
-			return nil, errors.Wrap(err, "error unmarshalling JSON of SyncGateway expvar response")
+			return nil, fmt.Errorf("error unmarshalling JSON of SyncGateway expvar response: %w", err)
 		}
 
 		m.expvarCache.cachedData = input
diff --git a/x-pack/osquerybeat/ext/osquery-extension/pkg/tables/elastic_file_analysis.go b/x-pack/osquerybeat/ext/osquery-extension/pkg/tables/elastic_file_analysis.go
index f531a8d6233..d5616a039aa 100644
--- a/x-pack/osquerybeat/ext/osquery-extension/pkg/tables/elastic_file_analysis.go
+++ b/x-pack/osquerybeat/ext/osquery-extension/pkg/tables/elastic_file_analysis.go
@@ -17,8 +17,9 @@ import (
 	"strings"
 	"syscall"
 
-	"github.com/elastic/beats/v7/x-pack/osquerybeat/internal/command"
 	"github.com/osquery/osquery-go/plugin/table"
+
+	"github.com/elastic/beats/v7/x-pack/osquerybeat/internal/command"
 )
 
 func ExecuteStderr(ctx context.Context, name string, arg ...string) (out string, err error) {