Remove github.com/pkg/errors with appropriate replacements (#3172)

* errors.Wrap* removal

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

* remove errors.Errorf

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

* Remove remaining calls

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

* Few more errors

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

* Fix golint errors

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

---------

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

.github/workflows/codeql.yaml

@@ -14,6 +14,10 @@ on:
 permissions:
   contents: read
 
+concurrency:
+  group: fission-codeql-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   CodeQL-Build:
     permissions:

.github/workflows/dependency-review.yml

@@ -12,6 +12,10 @@ on: [pull_request]
 permissions:
   contents: read
 
+concurrency:
+  group: fission-dependency-review-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   dependency-review:
     runs-on: ubuntu-24.04

.github/workflows/lint.yaml

@@ -23,6 +23,10 @@ env:
 permissions:
   contents: read
 
+concurrency:
+  group: fission-lint-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   lint:
     permissions:

.github/workflows/push_pr.yaml

@@ -29,6 +29,10 @@ env:
 permissions:
   contents: read
 
+concurrency:
+  group: fission-ci-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   # Job to run change detection
   integration-test:

.github/workflows/upgrade_test.yaml

@@ -29,6 +29,10 @@ env:
 permissions:
   contents: read
 
+concurrency:
+  group: fission-upgrade-test-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   upgrade-test:
     runs-on: ${{ matrix.os }}

.golangci.yaml

@@ -28,8 +28,9 @@ linters:
     # - gocritic
 linters-settings:
   errcheck:
-    ignore: go.uber.org/zap:Sync
+    exclude-functions:
+    - (*go.uber.org/zap.Logger).Sync
   goimports:
     # put imports beginning with prefix after 3rd-party packages;
     # it's a comma-separated list of prefixes
-    local: github.com/fission/fission
+    local-prefixes: github.com/fission/fission

cmd/fission-bundle/mqtrigger/mqtrigger.go

@@ -24,7 +24,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -41,12 +40,12 @@ import (
 func Start(ctx context.Context, clientGen crd.ClientGeneratorInterface, logger *zap.Logger, mgr manager.Interface, routerUrl string) error {
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get fission client")
+		return fmt.Errorf("failed to get fission client: %w", err)
 	}
 
 	err = crd.WaitForFunctionCRDs(ctx, logger, fissionClient)
 	if err != nil {
-		return errors.Wrap(err, "error waiting for CRDs")
+		return fmt.Errorf("error waiting for CRDs: %w", err)
 	}
 
 	mqType := (fv1.MessageQueueType)(os.Getenv("MESSAGE_QUEUE_TYPE"))

cmd/fission-cli/app/app.go

@@ -14,7 +14,8 @@ limitations under the License.
 package app
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -65,7 +66,7 @@ func App(clientOptions cmd.ClientOptions) *cobra.Command {
 				// }
 				client, err := cmd.NewClient(clientOptions)
 				if err != nil {
-					return errors.Wrap(err, "failed to get fission client")
+					return fmt.Errorf("failed to get fission client: %w", err)
 				}
 				cmd.SetClientset(*client)
 				return nil

go.mod

@@ -25,7 +25,6 @@ require (
 	github.com/mholt/archives v0.1.0
 	github.com/minio/minio-go v6.0.14+incompatible
 	github.com/ory/dockertest v3.3.5+incompatible
-	github.com/pkg/errors v0.9.1
 	github.com/prometheus/client_golang v1.20.5
 	github.com/prometheus/common v0.62.0
 	github.com/robfig/cron/v3 v3.0.1
@@ -217,6 +216,7 @@ require (
 	github.com/pierrec/lz4/v4 v4.1.22 // indirect
 	github.com/pires/go-proxyproto v0.8.0 // indirect
 	github.com/pjbgf/sha1cd v0.3.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect

pkg/apis/core/v1/zz_generated.deepcopy.go

@@ -21,7 +21,7 @@ limitations under the License.
 package v1
 
 import (
-	"k8s.io/api/autoscaling/v2"
+	v2 "k8s.io/api/autoscaling/v2"
 	corev1 "k8s.io/api/core/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )

pkg/builder/builder.go

@@ -31,7 +31,6 @@ import (
 	"time"
 
 	"github.com/dchest/uniuri"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	"github.com/fission/fission/pkg/info"
@@ -206,7 +205,7 @@ func (builder *Builder) reply(ctx context.Context, w http.ResponseWriter, pkgFil
 
 	rBody, err := json.Marshal(resp)
 	if err != nil {
-		e := errors.Wrap(err, "error encoding response body")
+		e := fmt.Errorf("error encoding response body: %w", err)
 		rBody = []byte(fmt.Sprintf(`{"buildLogs": "%s"}`, e.Error()))
 		statusCode = http.StatusInternalServerError
 	}
@@ -247,12 +246,12 @@ func (builder *Builder) build(ctx context.Context, command string, args []string
 
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		return "", errors.Wrap(err, "error creating stdout pipe for cmd")
+		return "", fmt.Errorf("error creating stdout pipe for cmd: %w", err)
 	}
 
 	stderr, err := cmd.StderrPipe()
 	if err != nil {
-		return "", errors.Wrap(err, "error creating stderr pipe for cmd")
+		return "", fmt.Errorf("error creating stderr pipe for cmd: %w", err)
 	}
 
 	// Init logs
@@ -263,7 +262,7 @@ func (builder *Builder) build(ctx context.Context, command string, args []string
 
 	err = cmd.Start()
 	if err != nil {
-		return "", errors.Wrap(err, "error starting cmd")
+		return "", fmt.Errorf("error starting cmd: %w", err)
 	}
 	fmt.Printf("========= START =========\n")
 	defer fmt.Printf("========= END ===========\n")
@@ -276,14 +275,14 @@ func (builder *Builder) build(ctx context.Context, command string, args []string
 	}
 
 	if err := scanner.Err(); err != nil {
-		scanErr := errors.Wrap(err, "error reading cmd output")
+		scanErr := fmt.Errorf("error reading cmd output: %w", err)
 		fmt.Println(scanErr)
 		return buildLogs, scanErr
 	}
 
 	err = cmd.Wait()
 	if err != nil {
-		cmdErr := errors.Wrapf(err, "error waiting for cmd %q", command)
+		cmdErr := fmt.Errorf("error waiting for cmd %q: %w", command, err)
 		fmt.Println(cmdErr)
 		return buildLogs, cmdErr
 	}

pkg/builder/client/client.go

@@ -20,12 +20,12 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
 	"strings"
 
 	"github.com/hashicorp/go-retryablehttp"
-	"github.com/pkg/errors"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.uber.org/zap"
 	"golang.org/x/net/context/ctxhttp"
@@ -68,26 +68,26 @@ func (c *client) Build(ctx context.Context, req *builder.PackageBuildRequest) (*
 
 	body, err := json.Marshal(req)
 	if err != nil {
-		return nil, errors.Wrap(err, "error marshaling json")
+		return nil, fmt.Errorf("error marshaling json: %w", err)
 	}
 
 	resp, err := ctxhttp.Post(ctx, c.httpClient.StandardClient(), c.url, "application/json", bytes.NewReader(body))
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error sending request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	rBody, err := io.ReadAll(resp.Body)
 	if err != nil {
 		logger.Error("error reading resp body", zap.Error(err))
-		return nil, err
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	pkgBuildResp := builder.PackageBuildResponse{}
 	err = json.Unmarshal(rBody, &pkgBuildResp)
 	if err != nil {
 		logger.Error("error parsing resp body", zap.Error(err))
-		return nil, err
+		return nil, fmt.Errorf("error parsing response body: %w", err)
 	}
 
 	return &pkgBuildResp, ferror.MakeErrorFromHTTP(resp)
@@ -98,7 +98,7 @@ func (c *client) Clean(ctx context.Context, srcPkgFilename string) error {
 
 	req, err := http.NewRequest(http.MethodDelete, c.getCleanUrl(srcPkgFilename), http.NoBody)
 	if err != nil {
-		return errors.Wrap(err, "failed to create http request for clean api")
+		return fmt.Errorf("error creating http request: %w", err)
 	}
 
 	resp, err := ctxhttp.Do(ctx, c.httpClient.StandardClient(), req)

pkg/buildermgr/buildermgr.go

@@ -18,10 +18,10 @@ package buildermgr
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -38,21 +38,21 @@ func Start(ctx context.Context, clientGen crd.ClientGeneratorInterface, logger *
 
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get fission client")
+		return fmt.Errorf("failed to get fission client: %w", err)
 	}
 	kubernetesClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get kubernetes client")
+		return fmt.Errorf("failed to get kubernetes client: %w", err)
 	}
 
 	err = crd.WaitForFunctionCRDs(ctx, logger, fissionClient)
 	if err != nil {
-		return errors.Wrap(err, "error waiting for CRDs")
+		return fmt.Errorf("error waiting for CRDs: %w", err)
 	}
 
 	fetcherConfig, err := fetcherConfig.MakeFetcherConfig("/packages")
 	if err != nil {
-		return errors.Wrap(err, "error making fetcher config")
+		return fmt.Errorf("error making fetcher config: %w", err)
 	}
 
 	podSpecPatch, err := util.GetSpecFromConfigMap(fv1.BuilderPodSpecPath)

pkg/buildermgr/common.go

@@ -24,7 +24,6 @@ import (
 	"time"
 
 	"github.com/dchest/uniuri"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -162,7 +161,7 @@ func updatePackage(ctx context.Context, logger *zap.Logger, fissionClient versio
 	if err != nil {
 		e := "error updating package"
 		logger.Error(e, zap.Error(err))
-		return nil, errors.Wrap(err, e)
+		return nil, fmt.Errorf("%s: %w", e, err)
 	}
 
 	// return resource version for function to update function package ref

pkg/canaryconfigmgr/config.go

@@ -18,8 +18,8 @@ package canaryconfigmgr
 
 import (
 	"context"
+	"fmt"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"k8s.io/client-go/kubernetes"
 
@@ -47,7 +47,7 @@ func ConfigureFeatures(ctx context.Context, logger *zap.Logger, unitTestMode boo
 	// in the future when new optional features are added, we need to add corresponding feature handlers and invoke them here
 	canaryCfgMgr, err := MakeCanaryConfigMgr(ctx, logger, fissionClient, kubeClient, featureConfig.CanaryConfig.PrometheusSvc)
 	if err != nil {
-		return errors.Wrap(err, "failed to start canary config manager")
+		return fmt.Errorf("failed to start canary config manager: %w", err)
 	}
 	canaryCfgMgr.Run(ctx, mgr)
 

pkg/canaryconfigmgr/prometheusClient.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
 	prometheus "github.com/prometheus/client_golang/api"
 	prometheusv1 "github.com/prometheus/client_golang/api/prometheus/v1"
 	"github.com/prometheus/common/model"
@@ -40,7 +39,7 @@ func MakePrometheusClient(logger *zap.Logger, prometheusSvc string) (*Prometheus
 
 	promApiClient, err := prometheus.NewClient(promApiConfig)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error creating prometheus api client for svc: %s", prometheusSvc)
+		return nil, fmt.Errorf("error creating prometheus api client for svc: %s: %w", prometheusSvc, err)
 	}
 
 	apiQueryClient := prometheusv1.NewAPI(promApiClient)
@@ -91,14 +90,14 @@ func (promApiClient *PrometheusApiClient) GetRequestsToFuncInWindow(ctx context.
 
 	reqs, err := promApiClient.executeQuery(ctx, queryString)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
+		return 0, fmt.Errorf("error executing query %s: %w", queryString, err)
 	}
 
 	queryString = fmt.Sprintf("fission_function_calls_total{%s} offset %v", queryLabels, window)
 
 	reqsInPrevWindow, err := promApiClient.executeQuery(ctx, queryString)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
+		return 0, fmt.Errorf("error executing query %s: %w", queryString, err)
 	}
 
 	reqsInCurrentWindow := reqs - reqsInPrevWindow
@@ -117,14 +116,14 @@ func (promApiClient *PrometheusApiClient) GetTotalFailedRequestsToFuncInWindow(c
 
 	failedRequests, err := promApiClient.executeQuery(ctx, queryString)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
+		return 0, fmt.Errorf("error executing query %s: %w", queryString, err)
 	}
 
 	queryString = fmt.Sprintf("fission_function_errors_total{%s} offset %v", queryLabels, window)
 
 	failedReqsInPrevWindow, err := promApiClient.executeQuery(ctx, queryString)
 	if err != nil {
-		return 0, errors.Wrapf(err, "error executing query: %s", queryString)
+		return 0, fmt.Errorf("error executing query %s: %w", queryString, err)
 	}
 
 	failedReqsInCurrentWindow := failedRequests - failedReqsInPrevWindow
@@ -142,7 +141,7 @@ func (promApiClient *PrometheusApiClient) executeQuery(ctx context.Context, quer
 
 	val, warn, err := promApiClient.client.Query(ctx, queryString, time.Now())
 	if err != nil {
-		return 0, errors.Wrapf(err, "error querying prometheus")
+		return 0, fmt.Errorf("error querying prometheus: %w", err)
 	}
 
 	if warn != nil {

pkg/crd/client.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"time"
 
+	kedaClient "github.com/kedacore/keda/v2/pkg/generated/clientset/versioned"
 	"go.uber.org/zap"
 	apiextensionsclient "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -32,7 +33,6 @@ import (
 
 	"github.com/fission/fission/pkg/generated/clientset/versioned"
 	"github.com/fission/fission/pkg/utils"
-	kedaClient "github.com/kedacore/keda/v2/pkg/generated/clientset/versioned"
 )
 
 const (

pkg/error/httperror_test.go

@@ -1,20 +1,20 @@
 package error
 
 import (
+	"fmt"
 	"net/http"
 	"testing"
 
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestIsNotFound(t *testing.T) {
 	errs := map[error]bool{
 		nil: false,
-		MakeError(ErrorNotFound, "someone not found"):                                          true,
+		MakeError(ErrorNotFound, "someone not found"):                                             true,
-		MakeError(ErrorTooManyRequests, "too many requests"):                                   false,
+		MakeError(ErrorTooManyRequests, "too many requests"):                                      false,
-		errors.Wrap(MakeError(ErrorNotFound, "someone not found"), "other information"):        true,
+		fmt.Errorf("other information: %w", MakeError(ErrorNotFound, "someone not found")):        true,
-		errors.Wrap(MakeError(ErrorTooManyRequests, "too many requests"), "other information"): false,
+		fmt.Errorf("other information: %w", MakeError(ErrorTooManyRequests, "too many requests")): false,
 	}
 
 	for err, want := range errs {
@@ -25,9 +25,9 @@ func TestIsNotFound(t *testing.T) {
 func TestGetHTTPError(t *testing.T) {
 	errs := map[int]error{
 		http.StatusBadRequest:      MakeError(ErrorInvalidArgument, ""),
-		http.StatusConflict:        errors.Wrap(MakeError(ErrorNameExists, ""), ""),
+		http.StatusConflict:        fmt.Errorf("%w", MakeError(ErrorNameExists, "")),
-		http.StatusNotFound:        errors.Wrap(MakeError(ErrorNotFound, ""), ""),
+		http.StatusNotFound:        fmt.Errorf("%w", MakeError(ErrorNotFound, "")),
-		http.StatusTooManyRequests: errors.Wrap(MakeError(ErrorTooManyRequests, "too many requests"), "other information"),
+		http.StatusTooManyRequests: fmt.Errorf("other information: %w", MakeError(ErrorTooManyRequests, "too many requests")),
 	}
 	for want, err := range errs {
 		code, _ := GetHTTPError(err)

pkg/executor/client/client.go

@@ -20,13 +20,13 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/url"
 	"strings"
 	"time"
 
 	"github.com/hashicorp/go-retryablehttp"
-	"github.com/pkg/errors"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.uber.org/zap"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -80,18 +80,18 @@ func (c *client) GetServiceForFunction(ctx context.Context, fn *fv1.Function) (s
 
 	body, err := json.Marshal(fn)
 	if err != nil {
-		return "", errors.Wrap(err, "could not marshal request body for getting service for function")
+		return "", fmt.Errorf("could not marshal request body for getting service for function: %w", err)
 	}
 
 	req, err := retryablehttp.NewRequestWithContext(ctx, "POST", executorURL, bytes.NewReader(body))
 	if err != nil {
-		return "", errors.Wrap(err, "could not create request for getting service for function")
+		return "", fmt.Errorf("could not create request for getting service for function: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
-		return "", errors.Wrap(err, "error posting to getting service for function")
+		return "", fmt.Errorf("error posting to getting service for function: %w", err)
 	}
 	defer resp.Body.Close()
 
@@ -101,7 +101,7 @@ func (c *client) GetServiceForFunction(ctx context.Context, fn *fv1.Function) (s
 
 	svcName, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return "", errors.Wrap(err, "error reading response body from getting service for function")
+		return "", fmt.Errorf("error reading response body from getting service for function: %w", err)
 	}
 
 	return string(svcName), nil
@@ -118,17 +118,17 @@ func (c *client) UnTapService(ctx context.Context, fnMeta metav1.ObjectMeta, exe
 
 	body, err := json.Marshal(tapSvc)
 	if err != nil {
-		return errors.Wrap(err, "could not marshal request body for getting service for function")
+		return fmt.Errorf("could not marshal request body for getting service for function: %w", err)
 	}
 	req, err := retryablehttp.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body))
 	if err != nil {
-		return errors.Wrap(err, "could not create request for untap service for function")
+		return fmt.Errorf("could not create request for untap service for function: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
-		return errors.Wrap(err, "error posting to getting service for function")
+		return fmt.Errorf("error posting to getting service for function: %w", err)
 	}
 	defer resp.Body.Close()
 
@@ -194,7 +194,7 @@ func (c *client) _tapService(ctx context.Context, tapSvcReqs []TapServiceRequest
 
 	req, err := retryablehttp.NewRequestWithContext(ctx, "POST", executorURL, bytes.NewReader(body))
 	if err != nil {
-		return errors.Wrap(err, "could not create request for tap service request")
+		return fmt.Errorf("could not create request for tap service request: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
 

pkg/executor/cms/cmscontroller.go

@@ -18,8 +18,8 @@ package cms
 
 import (
 	"context"
+	"fmt"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/tools/cache"
@@ -72,7 +72,7 @@ func refreshPods(ctx context.Context, logger *zap.Logger, funcs []fv1.Function,
 		if exists {
 			err = et.RefreshFuncPods(ctx, logger, f)
 		} else {
-			err = errors.Errorf("Unknown executor type '%s'", f.Spec.InvokeStrategy.ExecutionStrategy.ExecutorType)
+			err = fmt.Errorf("Unknown executor type '%s'", f.Spec.InvokeStrategy.ExecutionStrategy.ExecutorType)
 		}
 
 		if err != nil {

pkg/executor/executor.go

@@ -26,7 +26,6 @@ import (
 	"time"
 
 	"github.com/dchest/uniuri"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	k8sCache "k8s.io/client-go/tools/cache"
 
@@ -213,7 +212,7 @@ func (executor *Executor) serveCreateFuncServices(ctx context.Context) {
 				// It normally happened if there are multiple requests are
 				// waiting for the same function and executor failed to cre-
 				// ate service for function.
-				err = errors.Wrapf(err, "error getting service for function %s", fnName)
+				err = fmt.Errorf("error getting service for function %s: %w", fnName, err)
 				req.respChan <- &createFuncServiceResponse{
 					funcSvc: fsvc,
 					err:     err,
@@ -233,7 +232,7 @@ func (executor *Executor) createServiceForFunction(ctx context.Context, fn *fv1.
 	t := fn.Spec.InvokeStrategy.ExecutionStrategy.ExecutorType
 	e, ok := executor.executorTypes[t]
 	if !ok {
-		return nil, errors.Errorf("Unknown executor type '%s'", t)
+		return nil, fmt.Errorf("Unknown executor type '%s'", t)
 	}
 
 	fsvc, fsvcErr := e.GetFuncSvc(ctx, fn)
@@ -243,7 +242,7 @@ func (executor *Executor) createServiceForFunction(ctx context.Context, fn *fv1.
 			zap.Error(fsvcErr),
 			zap.String("function_name", fn.ObjectMeta.Name),
 			zap.String("function_namespace", fn.ObjectMeta.Namespace))
-		fsvcErr = errors.Wrap(fsvcErr, fmt.Sprintf("[%s] %s", fn.ObjectMeta.Name, e))
+		fsvcErr = fmt.Errorf("[%s] %s: %w", fn.ObjectMeta.Name, e, fsvcErr)
 	}
 
 	return fsvc, fsvcErr
@@ -254,7 +253,7 @@ func (executor *Executor) getFunctionServiceFromCache(ctx context.Context, fn *f
 	t := fn.Spec.InvokeStrategy.ExecutionStrategy.ExecutorType
 	e, ok := executor.executorTypes[t]
 	if !ok {
-		return nil, errors.Errorf("Unknown executor type '%s'", t)
+		return nil, fmt.Errorf("Unknown executor type '%s'", t)
 	}
 	return e.GetFuncSvcFromCache(ctx, fn)
 }
@@ -265,11 +264,11 @@ func StartExecutor(ctx context.Context, clientGen crd.ClientGeneratorInterface,
 
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return errors.Wrap(err, "error making the fission client")
+		return fmt.Errorf("error making the fission client: %w", err)
 	}
 	kubernetesClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		return errors.Wrap(err, "error making the kube client")
+		return fmt.Errorf("error making the kube client: %w", err)
 	}
 	metricsClient, err := clientGen.GetMetricsClient()
 	if err != nil {
@@ -278,12 +277,12 @@ func StartExecutor(ctx context.Context, clientGen crd.ClientGeneratorInterface,
 
 	err = crd.WaitForFunctionCRDs(ctx, logger, fissionClient)
 	if err != nil {
-		return errors.Wrap(err, "error waiting for CRDs")
+		return fmt.Errorf("error waiting for CRDs: %w", err)
 	}
 
 	fetcherConfig, err := fetcherConfig.MakeFetcherConfig("/userfunc")
 	if err != nil {
-		return errors.Wrap(err, "Error making fetcher config")
+		return fmt.Errorf("Error making fetcher config: %w", err)
 	}
 
 	executorInstanceID := strings.ToLower(uniuri.NewLen(8))
@@ -312,7 +311,7 @@ func StartExecutor(ctx context.Context, clientGen crd.ClientGeneratorInterface,
 		finformerFactory,
 		gpmInformerFactory, podSpecPatch)
 	if err != nil {
-		return errors.Wrap(err, "pool manager creation failed")
+		return fmt.Errorf("pool manager creation failed: %w", err)
 	}
 
 	executorLabel, err = utils.GetInformerLabelByExecutor(fv1.ExecutorTypeNewdeploy)
@@ -327,7 +326,7 @@ func StartExecutor(ctx context.Context, clientGen crd.ClientGeneratorInterface,
 		finformerFactory,
 		ndmInformerFactory, podSpecPatch)
 	if err != nil {
-		return errors.Wrap(err, "new deploy manager creation failed")
+		return fmt.Errorf("new deploy manager creation failed: %w", err)
 	}
 
 	executorLabel, err = utils.GetInformerLabelByExecutor(fv1.ExecutorTypeContainer)
@@ -341,7 +340,7 @@ func StartExecutor(ctx context.Context, clientGen crd.ClientGeneratorInterface,
 		executorInstanceID, finformerFactory,
 		cnmInformerFactory)
 	if err != nil {
-		return errors.Wrap(err, "container manager creation failed")
+		return fmt.Errorf("container manager creation failed: %w", err)
 	}
 
 	executorTypes := make(map[fv1.ExecutorType]executortype.ExecutorType)

pkg/executor/executortype/poolmgr/gp.go

@@ -19,6 +19,7 @@ package poolmgr
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math"
 	"net"
@@ -28,7 +29,6 @@ import (
 	"time"
 
 	"github.com/dchest/uniuri"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	appsv1 "k8s.io/api/apps/v1"
 	apiv1 "k8s.io/api/core/v1"
@@ -320,7 +320,7 @@ func (gp *GenericPool) choosePod(ctx context.Context, newLabels map[string]strin
 				// ending retry loop when the request canceled
 				gp.readyPodQueue.Done(key)
 				gp.readyPodQueue.AddAfter(key, expoDelay)
-				return "", nil, errors.Errorf("failed to relabel pod: %s", err)
+				return "", nil, fmt.Errorf("failed to relabel pod: %s", err)
 			} else if err != nil {
 				logger.Error("failed to relabel pod", zap.Error(err), zap.String("pod", chosenPod.Name), zap.Duration("delay", expoDelay))
 				gp.readyPodQueue.Done(key)
@@ -335,13 +335,13 @@ func (gp *GenericPool) choosePod(ctx context.Context, newLabels map[string]strin
 			// So we have to check both of them to ensure the patch success.
 			for k, v := range newLabels {
 				if newPod.Labels[k] != v {
-					return "", nil, errors.Errorf("value of necessary labels '%s' mismatch: want '%s', get '%v'",
+					return "", nil, fmt.Errorf("value of necessary labels '%s' mismatch: want '%s', get '%v'",
 						k, v, newPod.Labels[k])
 				}
 			}
 			for k, v := range annotations {
 				if newPod.Annotations[k] != v {
-					return "", nil, errors.Errorf("value of necessary annotations '%s' mismatch: want '%s', get '%v'",
+					return "", nil, fmt.Errorf("value of necessary annotations '%s' mismatch: want '%s', get '%v'",
 						k, v, newPod.Annotations[k])
 				}
 			}
@@ -415,7 +415,7 @@ func (gp *GenericPool) specializePod(ctx context.Context, pod *apiv1.Pod, fn *fv
 	// for fetcher we don't need to create a service, just talk to the pod directly
 	podIP := pod.Status.PodIP
 	if len(podIP) == 0 {
-		return errors.Errorf("Pod %s in namespace %s has no IP", pod.ObjectMeta.Name, pod.ObjectMeta.Namespace)
+		return fmt.Errorf("Pod %s in namespace %s has no IP", pod.ObjectMeta.Name, pod.ObjectMeta.Namespace)
 	}
 	for _, cm := range fn.Spec.ConfigMaps {
 		_, err := gp.kubernetesClient.CoreV1().ConfigMaps(gp.fnNamespace).Get(ctx, cm.Name, metav1.GetOptions{})
@@ -571,7 +571,7 @@ func (gp *GenericPool) getFuncSvc(ctx context.Context, fn *fv1.Function) (*fscac
 		}
 		if svc.ObjectMeta.Name != svcName {
 			go gp.scheduleDeletePod(context.Background(), pod.ObjectMeta.Name)
-			return nil, errors.Errorf("sanity check failed for svc %s", svc.ObjectMeta.Name)
+			return nil, fmt.Errorf("sanity check failed for svc %s", svc.ObjectMeta.Name)
 		}
 
 		// the fission router isn't in the same namespace, so return a

pkg/executor/executortype/poolmgr/gpm.go

@@ -27,7 +27,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/fission/fission/pkg/executor/metrics"
 	"go.opentelemetry.io/otel/attribute"
 	"go.uber.org/zap"
 	apiv1 "k8s.io/api/core/v1"
@@ -47,6 +46,7 @@ import (
 	"github.com/fission/fission/pkg/crd"
 	"github.com/fission/fission/pkg/executor/executortype"
 	"github.com/fission/fission/pkg/executor/fscache"
+	"github.com/fission/fission/pkg/executor/metrics"
 	"github.com/fission/fission/pkg/executor/reaper"
 	executorUtils "github.com/fission/fission/pkg/executor/util"
 	fetcherConfig "github.com/fission/fission/pkg/fetcher/config"

pkg/executor/fscache/functionServiceCache.go

@@ -22,7 +22,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.opentelemetry.io/otel/attribute"
 	"go.uber.org/zap"
 	apiv1 "k8s.io/api/core/v1"
@@ -292,7 +291,7 @@ func (fsc *FunctionServiceCache) Add(fsvc FuncSvc) (*FuncSvc, error) {
 		if IsNameExistError(err) {
 			err = nil
 		} else {
-			err = errors.Wrap(err, "error caching fsvc")
+			err = fmt.Errorf("error caching fsvc: %w", err)
 		}
 		return nil, err
 	}
@@ -304,7 +303,7 @@ func (fsc *FunctionServiceCache) Add(fsvc FuncSvc) (*FuncSvc, error) {
 		if IsNameExistError(err) {
 			err = nil
 		} else {
-			err = errors.Wrap(err, "error caching fsvc by function uid")
+			err = fmt.Errorf("error caching fsvc by function uid: %w", err)
 		}
 		return nil, err
 	}
@@ -383,10 +382,6 @@ func (fsc *FunctionServiceCache) DeleteFunctionSvc(ctx context.Context, fsvc *Fu
 	}
 }
 
-func (fsc *FunctionServiceCache) SetCPUUtilization(key crd.CacheKeyURG, svcHost string, cpuUsage resource.Quantity) {
-	fsc.connFunctionCache.SetCPUUtilization(key, svcHost, cpuUsage)
-}
-
 // DeleteOld deletes aged function service entries from cache.
 func (fsc *FunctionServiceCache) DeleteOld(fsvc *FuncSvc, minAge time.Duration) (bool, error) {
 	if time.Since(fsvc.Atime) < minAge {

pkg/executor/metrics/metrics.go

@@ -17,8 +17,9 @@ limitations under the License.
 package metrics
 
 import (
-	"github.com/fission/fission/pkg/utils/metrics"
 	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/fission/fission/pkg/utils/metrics"
 )
 
 var (

pkg/executor/util/util_test.go

@@ -23,10 +23,10 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
+	apiv1 "k8s.io/api/core/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 	"github.com/fission/fission/pkg/utils/loggerfactory"
-	apiv1 "k8s.io/api/core/v1"
 )
 
 func TestGetSpecFromConfigMap(t *testing.T) {

pkg/fetcher/client/client.go

@@ -4,12 +4,12 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.uber.org/zap"
 	"golang.org/x/net/context/ctxhttp"
@@ -104,7 +104,7 @@ func sendRequest(logger *zap.Logger, ctx context.Context, httpClient *http.Clien
 		// skip retry and return directly due to context deadline exceeded
 		if err == context.DeadlineExceeded {
 			msg := "error specializing function pod, either increase the specialization timeout for function or check function pod log would help."
-			err = errors.Wrap(err, msg)
+			err = fmt.Errorf("%s: %w", msg, err)
 			logger.Error(msg, zap.Error(err), zap.String("url", url))
 			return nil, err
 		}

pkg/fetcher/config/config.go

@@ -7,7 +7,6 @@ import (
 	"path/filepath"
 
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	apiv1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -305,7 +304,7 @@ func (cfg *Config) addFetcherToPodSpecWithCommand(podSpec *apiv1.PodSpec, mainCo
 		for _, existingContainer := range podSpec.Containers {
 			existingContainerNames = append(existingContainerNames, existingContainer.Name)
 		}
-		return errors.Errorf("could not find main container '%s' in given PodSpec. Found: %v",
+		return fmt.Errorf("could not find main container '%s' in given PodSpec. Found: %v",
 			mainContainerName,
 			existingContainerNames)
 	}

pkg/fetcher/fetcher.go

@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -29,7 +30,6 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/pkg/errors"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.uber.org/zap"
 	"golang.org/x/net/context/ctxhttp"
@@ -92,21 +92,21 @@ func MakeFetcher(logger *zap.Logger, clientGen crd.ClientGeneratorInterface, sha
 
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return nil, errors.Wrap(err, "error making the fission client")
+		return nil, fmt.Errorf("error making the fission client: %w", err)
 	}
 	kubeClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		return nil, errors.Wrap(err, "error making the kube client")
+		return nil, fmt.Errorf("error making the kube client: %w", err)
 	}
 
 	name, err := os.ReadFile(podInfoMountDir + "/name")
 	if err != nil {
-		return nil, errors.Wrap(err, "error reading pod name from downward volume")
+		return nil, fmt.Errorf("error reading pod name from downward volume: %w", err)
 	}
 
 	namespace, err := os.ReadFile(podInfoMountDir + "/namespace")
 	if err != nil {
-		return nil, errors.Wrap(err, "error reading pod namespace from downward volume")
+		return nil, fmt.Errorf("error reading pod namespace from downward volume: %w", err)
 	}
 
 	hc := &http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)}
@@ -140,7 +140,7 @@ func writeSecretOrConfigMap(dataMap map[string][]byte, dirPath string) error {
 		writeFilePath := filepath.Join(dirPath, key)
 		err := os.WriteFile(writeFilePath, val, 0750)
 		if err != nil {
-			return errors.Wrapf(err, "Failed to write file %s", writeFilePath)
+			return fmt.Errorf("failed to write file %s: %w", writeFilePath, err)
 		}
 	}
 	return nil
@@ -255,7 +255,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 	storePath, err := utils.SanitizeFilePath(filepath.Join(fetcher.sharedVolumePath, req.Filename), fetcher.sharedVolumePath)
 	if err != nil {
 		logger.Error(err.Error(), zap.String("filename", req.Filename))
-		return http.StatusBadRequest, errors.New(fmt.Sprintf("%s, request: %v", err, req))
+		return http.StatusBadRequest, fmt.Errorf("%s, request: %v", err, req)
 	}
 
 	// verify first if the file already exists.
@@ -270,7 +270,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 	tmpPath, err := utils.SanitizeFilePath(storePath+".tmp", fetcher.sharedVolumePath)
 	if err != nil {
 		logger.Error(err.Error(), zap.String("filename", req.Filename))
-		return http.StatusBadRequest, errors.New(fmt.Sprintf("%s, request: %v", err, req))
+		return http.StatusBadRequest, fmt.Errorf("%s, request: %v", err, req)
 	}
 
 	if req.FetchType == fv1.FETCH_URL {
@@ -284,7 +284,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 		if err != nil {
 			e := "failed to download url"
 			logger.Error(e, zap.Error(err), zap.String("url", req.Url))
-			return http.StatusBadRequest, errors.Wrapf(err, "%s: %s", e, req.Url)
+			return http.StatusBadRequest, fmt.Errorf("%s: %s: %w", e, req.Url, err)
 		}
 	} else {
 		var archive *fv1.Archive
@@ -301,7 +301,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 					zap.String("package_name", pkg.ObjectMeta.Name),
 					zap.String("package_namespace", pkg.ObjectMeta.Namespace),
 					zap.Any("package_build_status", pkg.Status.BuildStatus))
-				return http.StatusInternalServerError, errors.New(fmt.Sprintf("%s: pkg %s.%s has a status of %s", e, pkg.ObjectMeta.Name, pkg.ObjectMeta.Namespace, pkg.Status.BuildStatus))
+				return http.StatusInternalServerError, fmt.Errorf("%s: pkg %s.%s has a status of %s", e, pkg.ObjectMeta.Name, pkg.ObjectMeta.Namespace, pkg.Status.BuildStatus)
 			}
 			archive = &pkg.Spec.Deployment
 		} else {
@@ -315,7 +315,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 			if err != nil {
 				e := "failed to write file"
 				logger.Error(e, zap.Error(err), zap.String("location", tmpPath))
-				return http.StatusInternalServerError, errors.Wrapf(err, "%s %s", e, tmpPath)
+				return http.StatusInternalServerError, fmt.Errorf("%s %s: %w", e, tmpPath, err)
 			}
 			otelUtils.SpanTrackEvent(ctx, "archiveLiteral", otelUtils.GetAttributesForPackage(pkg)...)
 		} else {
@@ -329,7 +329,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 			if err != nil {
 				e := "failed to download url"
 				logger.Error(e, zap.Error(err), zap.String("url", req.Url))
-				return http.StatusBadRequest, errors.Wrapf(err, "%s %s", e, req.Url)
+				return http.StatusBadRequest, fmt.Errorf("%s %s: %w", e, req.Url, err)
 			}
 
 			// check file integrity only if checksum is not empty.
@@ -338,13 +338,13 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 				if err != nil {
 					e := "failed to get checksum"
 					logger.Error(e, zap.Error(err))
-					return http.StatusBadRequest, errors.Wrap(err, e)
+					return http.StatusBadRequest, fmt.Errorf("%s: %w", e, err)
 				}
 				err = verifyChecksum(checksum, &archive.Checksum)
 				if err != nil {
 					e := "failed to verify checksum"
 					logger.Error(e, zap.Error(err))
-					return http.StatusBadRequest, errors.Wrap(err, e)
+					return http.StatusBadRequest, fmt.Errorf("%s: %w", e, err)
 				}
 			}
 		}
@@ -373,7 +373,7 @@ func (fetcher *Fetcher) Fetch(ctx context.Context, pkg *fv1.Package, req Functio
 			zap.Error(err),
 			zap.String("original_path", tmpPath),
 			zap.String("rename_path", storePath))
-		return http.StatusInternalServerError, err
+		return http.StatusInternalServerError, fmt.Errorf("error renaming file: %w", err)
 	}
 
 	otelUtils.SpanTrackEvent(ctx, "packageFetched", otelUtils.GetAttributesForPackage(pkg)...)
@@ -409,7 +409,7 @@ func (fetcher *Fetcher) FetchSecretsAndCfgMaps(ctx context.Context, secrets []fv
 			secretDir, err := utils.SanitizeFilePath(filepath.Join(fetcher.sharedSecretPath, secret.Namespace, secret.Name), fetcher.sharedSecretPath)
 			if err != nil {
 				logger.Error(err.Error(), zap.String("directory", secretDir), zap.String("secret_name", secret.Name), zap.String("secret_namespace", secret.Namespace))
-				return http.StatusBadRequest, errors.New(fmt.Sprintf("%s, request: %v", err, secret))
+				return http.StatusBadRequest, fmt.Errorf("%s, request: %v", err, secret)
 			}
 
 			err = os.MkdirAll(secretDir, os.ModeDir|0750)
@@ -420,7 +420,7 @@ func (fetcher *Fetcher) FetchSecretsAndCfgMaps(ctx context.Context, secrets []fv
 					zap.String("directory", secretDir),
 					zap.String("secret_name", secret.Name),
 					zap.String("secret_namespace", secret.Namespace))
-				return http.StatusInternalServerError, errors.Wrapf(err, "%s: %s", e, secretDir)
+				return http.StatusInternalServerError, fmt.Errorf("%s: %s: %w", e, secretDir, err)
 			}
 			err = writeSecretOrConfigMap(data.Data, secretDir)
 			if err != nil {
@@ -461,8 +461,8 @@ func (fetcher *Fetcher) FetchSecretsAndCfgMaps(ctx context.Context, secrets []fv
 			configDir, err := utils.SanitizeFilePath(filepath.Join(fetcher.sharedConfigPath, config.Namespace, config.Name), fetcher.sharedConfigPath)
 			if err != nil {
 				logger.Error(err.Error(), zap.String("directory", configDir), zap.String("config_map_name", config.Name), zap.String("config_map_namespace", config.Namespace))
-				return http.StatusBadRequest, errors.New(fmt.Sprintf("%s, request: %v", err,
+				return http.StatusBadRequest, fmt.Errorf("%s, request: %v", err,
-					config))
+					config)
 			}
 
 			err = os.MkdirAll(configDir, os.ModeDir|0750)
@@ -473,7 +473,7 @@ func (fetcher *Fetcher) FetchSecretsAndCfgMaps(ctx context.Context, secrets []fv
 					zap.String("directory", configDir),
 					zap.String("config_map_name", config.Name),
 					zap.String("config_map_namespace", config.Namespace))
-				return http.StatusInternalServerError, errors.Wrapf(err, "%s: %s", e, configDir)
+				return http.StatusInternalServerError, fmt.Errorf("%s: %s: %w", e, configDir, err)
 			}
 			configMap := make(map[string][]byte)
 			for key, val := range data.Data {
@@ -617,7 +617,7 @@ func (fetcher *Fetcher) UploadHandler(w http.ResponseWriter, r *http.Request) {
 func (fetcher *Fetcher) rename(src string, dst string) error {
 	err := os.Rename(src, dst)
 	if err != nil {
-		return errors.Wrap(err, "failed to move file")
+		return fmt.Errorf("failed to move file: %w", err)
 	}
 	return nil
 }
@@ -673,17 +673,17 @@ func (fetcher *Fetcher) SpecializePod(ctx context.Context, fetchReq FunctionFetc
 
 	pkg, err := fetcher.getPkgInformation(ctx, fetchReq)
 	if err != nil {
-		return errors.Wrap(err, "error getting package information")
+		return fmt.Errorf("error getting package information: %w", err)
 	}
 
 	_, err = fetcher.Fetch(ctx, pkg, fetchReq)
 	if err != nil {
-		return errors.Wrap(err, "error fetching deploy package")
+		return fmt.Errorf("error fetching deploy package: %w", err)
 	}
 
 	_, err = fetcher.FetchSecretsAndCfgMaps(ctx, fetchReq.Secrets, fetchReq.ConfigMaps)
 	if err != nil {
-		return errors.Wrap(err, "error fetching secrets/configs")
+		return fmt.Errorf("error fetching secrets/configs: %w", err)
 	}
 
 	// Specialize the pod
@@ -695,7 +695,7 @@ func (fetcher *Fetcher) SpecializePod(ctx context.Context, fetchReq FunctionFetc
 
 	loadPayload, err := json.Marshal(loadReq)
 	if err != nil {
-		return errors.Wrap(err, "error encoding load request")
+		return fmt.Errorf("error encoding load request: %w", err)
 	}
 
 	// Instead of using "localhost", here we use "127.0.0.1" for
@@ -739,10 +739,10 @@ func (fetcher *Fetcher) SpecializePod(ctx context.Context, fetchReq FunctionFetc
 			err = ferror.MakeErrorFromHTTP(resp)
 		}
 
-		return errors.Wrap(err, "error specializing function pod")
+		return fmt.Errorf("error specializing function pod: %w", err)
 	}
 
-	return errors.Wrapf(err, "error specializing function pod after %v times", maxRetries)
+	return fmt.Errorf("error specializing function pod after %v times: %w", maxRetries, err)
 }
 
 // WsStartHandler is used to generate websocket events in Kubernetes

pkg/fission-cli/cmd/canaryconfig/create.go

@@ -17,10 +17,10 @@ limitations under the License.
 package canaryconfig
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -57,7 +57,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) (err error) {
 
 	_, fnNs, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in creating canaryconfig")
+		return fmt.Errorf("error in creating canaryconfig: %w", err)
 	}
 	incrementStep := input.Int(flagkey.CanaryWeightIncrement)
 	failureThreshold := input.Int(flagkey.CanaryFailureThreshold)
@@ -66,13 +66,13 @@ func (opts *CreateSubCommand) complete(input cli.Input) (err error) {
 	// check for time parsing
 	_, err = time.ParseDuration(incrementInterval)
 	if err != nil {
-		return errors.Wrap(err, "error parsing time duration")
+		return fmt.Errorf("error parsing time duration: %w", err)
 	}
 
 	// check that the trigger exists in the same namespace.
 	htTrigger, err := opts.Client().FissionClientSet.CoreV1().HTTPTriggers(fnNs).Get(input.Context(), ht, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error finding http trigger referenced in the canary config")
+		return fmt.Errorf("error finding http trigger referenced in the canary config: %w", err)
 	}
 
 	// check that the trigger has function reference type function weights
@@ -95,7 +95,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) (err error) {
 	fnList := []string{newFunc, oldFunc}
 	err = util.CheckFunctionExistence(input.Context(), opts.Client(), fnList, fnNs)
 	if err != nil {
-		return errors.Wrap(err, "error checking functions existence")
+		return fmt.Errorf("error checking functions existence: %w", err)
 	}
 
 	// finally create canaryCfg in the same namespace as the functions referenced
@@ -124,7 +124,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) (err error) {
 func (opts *CreateSubCommand) run(input cli.Input) error {
 	_, err := opts.Client().FissionClientSet.CoreV1().CanaryConfigs(opts.canary.ObjectMeta.Namespace).Create(input.Context(), opts.canary, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating canary config")
+		return fmt.Errorf("error creating canary config: %w", err)
 	}
 
 	fmt.Printf("canary config '%s' created\n", opts.canary.ObjectMeta.Name)

pkg/fission-cli/cmd/canaryconfig/delete.go

@@ -19,7 +19,6 @@ package canaryconfig
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -39,7 +38,7 @@ func Delete(input cli.Input) error {
 func (opts *DeleteSubCommand) run(input cli.Input) (err error) {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceCanary)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting canaryConfig ")
+		return fmt.Errorf("error in deleting canaryConfig: %w", err)
 	}
 
 	err = opts.Client().FissionClientSet.CoreV1().CanaryConfigs(namespace).Delete(input.Context(), input.String(flagkey.CanaryName), metav1.DeleteOptions{})
@@ -47,7 +46,7 @@ func (opts *DeleteSubCommand) run(input cli.Input) (err error) {
 		if input.Bool(flagkey.IgnoreNotFound) && util.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(err, "error deleting canary config")
+		return fmt.Errorf("error deleting canary config: %w", err)
 	}
 
 	fmt.Printf("canaryconfig '%v.%v' deleted\n", input.String(flagkey.CanaryName), namespace)

pkg/fission-cli/cmd/canaryconfig/get.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -41,12 +40,12 @@ func (opts *GetSubCommand) run(input cli.Input) (err error) {
 
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceCanary)
 	if err != nil {
-		return errors.Wrap(err, "error getting canary config")
+		return fmt.Errorf("error getting canary config: %w", err)
 	}
 
 	canaryCfg, err := opts.Client().FissionClientSet.CoreV1().CanaryConfigs(namespace).Get(input.Context(), input.String(flagkey.CanaryName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting canary config")
+		return fmt.Errorf("error getting canary config: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/canaryconfig/list.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -49,7 +48,7 @@ func (opts *ListSubCommand) do(input cli.Input) error {
 func (opts *ListSubCommand) complete(input cli.Input) (err error) {
 	_, opts.namespace, err = opts.GetResourceNamespace(input, flagkey.NamespaceCanary)
 	if err != nil {
-		return errors.Wrap(err, "error in listing canary config ")
+		return fmt.Errorf("error in listing canary config: %w", err)
 	}
 	return nil
 }
@@ -62,7 +61,7 @@ func (opts *ListSubCommand) run(input cli.Input) (err error) {
 	canaryCfgs, err := opts.Client().FissionClientSet.CoreV1().CanaryConfigs(opts.namespace).List(input.Context(), metav1.ListOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, "error listing canary config")
+		return fmt.Errorf("error listing canary config: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/canaryconfig/update.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -50,7 +49,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 	// get the current config
 	_, ns, err := opts.GetResourceNamespace(input, flagkey.NamespaceCanary)
 	if err != nil {
-		return errors.Wrap(err, "error updating canary config")
+		return fmt.Errorf("error updating canary config: %w", err)
 	}
 	incrementStep := input.Int(flagkey.CanaryWeightIncrement)
 	failureThreshold := input.Int(flagkey.CanaryFailureThreshold)
@@ -59,12 +58,12 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 	// check for time parsing
 	_, err = time.ParseDuration(incrementInterval)
 	if err != nil {
-		return errors.Wrap(err, "error parsing time duration")
+		return fmt.Errorf("error parsing time duration: %w", err)
 	}
 
 	canaryCfg, err := opts.Client().FissionClientSet.CoreV1().CanaryConfigs(ns).Get(input.Context(), input.String(flagkey.CanaryName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting canary config")
+		return fmt.Errorf("error getting canary config: %w", err)
 	}
 
 	var updateNeeded bool
@@ -93,7 +92,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 func (opts *UpdateSubCommand) run(input cli.Input) error {
 	_, err := opts.Client().FissionClientSet.CoreV1().CanaryConfigs(opts.canary.ObjectMeta.Namespace).Update(input.Context(), opts.canary, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating canary config")
+		return fmt.Errorf("error updating canary config: %w", err)
 	}
 	fmt.Printf("canary config '%v' updated\n", opts.canary.ObjectMeta.Name)
 	return nil

pkg/fission-cli/cmd/environment/create.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	apiv1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -101,7 +100,7 @@ func (opts *CreateSubCommand) run(input cli.Input) (err error) {
 		specFile := fmt.Sprintf("env-%v.yaml", opts.env.ObjectMeta.Name)
 		err = spec.SpecSave(*opts.env, specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving environment spec")
+			return fmt.Errorf("error saving environment spec: %w", err)
 		}
 		return nil
 	}
@@ -110,7 +109,7 @@ func (opts *CreateSubCommand) run(input cli.Input) (err error) {
 
 	_, err = opts.Client().FissionClientSet.CoreV1().Environments(opts.env.Namespace).Create(input.Context(), opts.env, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating resource")
+		return fmt.Errorf("error creating resource: %w", err)
 	}
 
 	fmt.Printf("environment '%v' created\n", opts.env.ObjectMeta.Name)

pkg/fission-cli/cmd/environment/delete.go

@@ -17,9 +17,9 @@ limitations under the License.
 package environment
 
 import (
+	"errors"
 	"fmt"
 
-	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -41,7 +41,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) (err error) {
 
 	_, currentContextNS, err := opts.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
 	if err != nil {
-		return errors.Wrap(err, "error creating environment")
+		return fmt.Errorf("error creating environment: %w", err)
 	}
 	console.Verbose(2, "Searching for resource in  %s Namespace", currentContextNS)
 	envName := input.String(flagkey.EnvName)
@@ -49,7 +49,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) (err error) {
 	if !input.Bool(flagkey.EnvForce) {
 		fns, err := opts.Client().FissionClientSet.CoreV1().Functions(metav1.NamespaceAll).List(input.Context(), metav1.ListOptions{})
 		if err != nil {
-			return errors.Wrap(err, "Error getting functions wrt environment.")
+			return fmt.Errorf("Error getting functions wrt environment.: %w", err)
 		}
 
 		for _, fn := range fns.Items {
@@ -65,7 +65,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) (err error) {
 		if input.Bool(flagkey.IgnoreNotFound) && kerrors.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(err, "error deleting environment")
+		return fmt.Errorf("error deleting environment: %w", err)
 	}
 
 	fmt.Printf("environment '%s' deleted\n", envName)

pkg/fission-cli/cmd/environment/get.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -41,12 +40,12 @@ func (opts *GetSubCommand) do(input cli.Input) (err error) {
 
 	_, currentNS, err := opts.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
 	if err != nil {
-		return errors.Wrap(err, "error creating environment")
+		return fmt.Errorf("error creating environment: %w", err)
 	}
 
 	env, err := opts.Client().FissionClientSet.CoreV1().Environments(currentNS).Get(input.Context(), input.String(flagkey.EnvName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting environment")
+		return fmt.Errorf("error getting environment: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/environment/list.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -41,7 +40,7 @@ func (opts *ListSubCommand) do(input cli.Input) (err error) {
 
 	_, currentNS, err := opts.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
 	if err != nil {
-		return errors.Wrap(err, "error creating environment")
+		return fmt.Errorf("error creating environment: %w", err)
 	}
 
 	if input.Bool(flagkey.AllNamespaces) {
@@ -50,7 +49,7 @@ func (opts *ListSubCommand) do(input cli.Input) (err error) {
 
 	response, err := opts.Client().FissionClientSet.CoreV1().Environments(currentNS).List(input.Context(), metav1.ListOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error listing environments")
+		return fmt.Errorf("error listing environments: %w", err)
 	}
 
 	envs := response.Items

pkg/fission-cli/cmd/environment/pods.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 
@@ -44,12 +43,12 @@ func (opts *ListPodsSubCommand) do(input cli.Input) (err error) {
 
 	_, currentNS, err := opts.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
 	if err != nil {
-		return errors.Wrap(err, "error creating environment")
+		return fmt.Errorf("error creating environment: %w", err)
 	}
 
 	_, err = opts.Client().FissionClientSet.CoreV1().Environments(currentNS).Get(input.Context(), input.String(flagkey.EnvName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting environment")
+		return fmt.Errorf("error getting environment: %w", err)
 	}
 
 	// label selector
@@ -65,7 +64,7 @@ func (opts *ListPodsSubCommand) do(input cli.Input) (err error) {
 		LabelSelector: labels.Set(selector).AsSelector().String(),
 	})
 	if err != nil {
-		return errors.Wrap(err, "error listing environments")
+		return fmt.Errorf("error listing environments: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)

pkg/fission-cli/cmd/environment/update.go

@@ -17,11 +17,12 @@ limitations under the License.
 package environment
 
 import (
+	"errors"
 	"fmt"
 	"strconv"
 
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
+
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -57,11 +58,11 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 
 	_, currentContextNS, err := opts.GetResourceNamespace(input, flagkey.NamespaceEnvironment)
 	if err != nil {
-		return errors.Wrap(err, "error creating environment")
+		return fmt.Errorf("error creating environment: %w", err)
 	}
 	env, err := opts.Client().FissionClientSet.CoreV1().Environments(currentContextNS).Get(input.Context(), input.String(flagkey.EnvName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error finding environment")
+		return fmt.Errorf("error finding environment: %w", err)
 	}
 
 	env, err = updateExistingEnvironmentWithCmd(env, input)
@@ -89,13 +90,13 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("env-%s.yaml", m.Name)
 		err = spec.SpecSave(*opts.env, specFile, true)
 		if err != nil {
-			return errors.Wrap(err, "error saving environment spec")
+			return fmt.Errorf("error saving environment spec: %w", err)
 		}
 		return nil
 	}
 	enew, err := opts.Client().FissionClientSet.CoreV1().Environments(opts.env.ObjectMeta.Namespace).Update(input.Context(), opts.env, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating environment")
+		return fmt.Errorf("error updating environment: %w", err)
 	}
 
 	fmt.Printf("environment '%v' updated\n", enew.ObjectMeta.Name)
@@ -151,7 +152,7 @@ func updateExistingEnvironmentWithCmd(env *fv1.Environment, input cli.Input) (*f
 		mincpu := input.Int(flagkey.RuntimeMincpu)
 		cpuRequest, err := resource.ParseQuantity(strconv.Itoa(mincpu) + "m")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse mincpu"))
+			e = multierror.Append(e, fmt.Errorf("failed to parse mincpu: %w", err))
 		}
 		env.Spec.Resources.Requests[v1.ResourceCPU] = cpuRequest
 	}
@@ -160,7 +161,7 @@ func updateExistingEnvironmentWithCmd(env *fv1.Environment, input cli.Input) (*f
 		maxcpu := input.Int(flagkey.RuntimeMaxcpu)
 		cpuLimit, err := resource.ParseQuantity(strconv.Itoa(maxcpu) + "m")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxcpu"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse maxcpu: %w", err))
 		}
 		env.Spec.Resources.Limits[v1.ResourceCPU] = cpuLimit
 	}
@@ -169,7 +170,7 @@ func updateExistingEnvironmentWithCmd(env *fv1.Environment, input cli.Input) (*f
 		minmem := input.Int(flagkey.RuntimeMinmemory)
 		memRequest, err := resource.ParseQuantity(strconv.Itoa(minmem) + "Mi")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse minmemory"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse minmemory: %w", err))
 		}
 		env.Spec.Resources.Requests[v1.ResourceMemory] = memRequest
 	}
@@ -178,7 +179,7 @@ func updateExistingEnvironmentWithCmd(env *fv1.Environment, input cli.Input) (*f
 		maxmem := input.Int(flagkey.RuntimeMaxmemory)
 		memLimit, err := resource.ParseQuantity(strconv.Itoa(maxmem) + "Mi")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxmemory"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse maxmemory: %w", err))
 		}
 		env.Spec.Resources.Limits[v1.ResourceMemory] = memLimit
 	}

pkg/fission-cli/cmd/function/create.go

@@ -17,9 +17,9 @@ limitations under the License.
 package function
 
 import (
+	"errors"
 	"fmt"
 
-	"github.com/pkg/errors"
 	asv2 "k8s.io/api/autoscaling/v2"
 	apiv1 "k8s.io/api/core/v1"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
@@ -67,7 +67,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 	userProvidedNS, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error retrieving namespace information")
+		return fmt.Errorf("error retrieving namespace information: %w", err)
 	}
 
 	// user wants a spec, create a yaml file with package and function
@@ -93,7 +93,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 	fnTimeout := input.Int(flagkey.FnExecutionTimeout)
 	if fnTimeout <= 0 {
-		return errors.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
+		return fmt.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
 	}
 
 	fnIdleTimeout := input.Int(flagkey.FnIdleTimeout)
@@ -119,7 +119,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 	cfgMapNames := input.StringSlice(flagkey.FnCfgMap)
 
 	if input.String(flagkey.FnExecutorType) == string(fv1.ExecutorTypeContainer) {
-		return errors.Errorf("this command does not support creating function of executor type container. Check `fission function run-container --help`")
+		return fmt.Errorf("this command does not support creating function of executor type container. Check `fission function run-container --help`")
 	}
 
 	invokeStrategy, err := getInvokeStrategy(input, nil)
@@ -141,7 +141,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 			fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 			if err != nil {
-				return errors.Wrap(err, fmt.Sprintf("error reading spec in '%s'", specDir))
+				return fmt.Errorf("error reading spec in '%s': %w", specDir, err)
 			}
 
 			obj := fr.SpecExists(&fv1.Package{ // In case of spec I might or might not have the `fnNamespace`, how will I get pkg objectMeta here.
@@ -151,7 +151,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 				},
 			}, true, false)
 			if obj == nil {
-				return errors.Errorf("please create package %s spec file with namespace %s before referencing it", pkgName, userProvidedNS)
+				return fmt.Errorf("please create package %s spec file with namespace %s before referencing it", pkgName, userProvidedNS)
 			}
 
 			pkg = obj.(*fv1.Package)
@@ -160,7 +160,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 			// use existing package
 			pkg, err = opts.Client().FissionClientSet.CoreV1().Packages(fnNamespace).Get(input.Context(), pkgName, metav1.GetOptions{})
 			if err != nil {
-				return errors.Wrap(err, fmt.Sprintf("read package in '%s' in Namespace: %s. Package needs to be present in the same namespace as function", pkgName, fnNamespace))
+				return fmt.Errorf("read package in '%s' in Namespace: %s. Package needs to be present in the same namespace as function: %w", pkgName, fnNamespace, err)
 			}
 			pkgMetadata = &pkg.ObjectMeta
 		}
@@ -180,7 +180,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 			fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 			if err != nil {
-				return errors.Wrap(err, fmt.Sprintf("error reading spec in '%s'", specDir))
+				return fmt.Errorf("error reading spec in '%s': %w", specDir, err)
 			}
 			exists, err := fr.ExistsInSpecs(fv1.Environment{
 				ObjectMeta: metav1.ObjectMeta{
@@ -201,7 +201,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 				if e, ok := err.(ferror.Error); ok && e.Code == ferror.ErrorNotFound {
 					console.Warn(fmt.Sprintf("Environment \"%s\" does not exist. Please create the environment before executing the function. \nFor example: `fission env create --name %s --envns %s --image <image>`\n", envName, envName, fnNamespace))
 				} else {
-					return errors.Wrap(err, "error retrieving environment information")
+					return fmt.Errorf("error retrieving environment information: %w", err)
 				}
 			}
 		}
@@ -228,7 +228,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 		pkgMetadata, err = _package.CreatePackage(input, opts.Client(), pkgName, fnNamespace, envName,
 			srcArchiveFiles, deployArchiveFiles, buildcmd, specDir, opts.specFile, noZip, userProvidedNS)
 		if err != nil {
-			return errors.Wrap(err, "error creating package")
+			return fmt.Errorf("error creating package: %w", err)
 		}
 	}
 
@@ -244,7 +244,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 					if k8serrors.IsNotFound(err) {
 						console.Warn(fmt.Sprintf("Secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace))
 					} else {
-						return errors.Wrapf(err, "error checking secret %s", secretName)
+						return fmt.Errorf("error checking secret %s: %w", secretName, err)
 					}
 				}
 				newSecret := fv1.SecretReference{
@@ -274,7 +274,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 					if k8serrors.IsNotFound(err) {
 						console.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as function", cfgMapName, fnNamespace))
 					} else {
-						return errors.Wrapf(err, "error checking configmap %s", cfgMapName)
+						return fmt.Errorf("error checking configmap %s: %w", cfgMapName, err)
 					}
 				}
 				newCfgMap := fv1.ConfigMapReference{
@@ -368,14 +368,14 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	if input.Bool(flagkey.SpecSave) {
 		err := spec.SpecSave(*opts.function, opts.specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving function spec")
+			return fmt.Errorf("error saving function spec: %w", err)
 		}
 		return nil
 	}
 
 	_, err := opts.Client().FissionClientSet.CoreV1().Functions(opts.function.ObjectMeta.Namespace).Create(input.Context(), opts.function, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating function")
+		return fmt.Errorf("error creating function: %w", err)
 	}
 
 	fmt.Printf("function '%s' created\n", opts.function.ObjectMeta.Name)
@@ -420,7 +420,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	}
 	_, err = opts.Client().FissionClientSet.CoreV1().HTTPTriggers(opts.function.ObjectMeta.Namespace).Create(input.Context(), ht, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating HTTP trigger")
+		return fmt.Errorf("error creating HTTP trigger: %w", err)
 	}
 
 	fmt.Printf("route created: %s %s -> %s\n", methods, triggerUrl, opts.function.ObjectMeta.Name)
@@ -490,7 +490,7 @@ func getExecutorType(input cli.Input) (executorType fv1.ExecutorType, err error)
 	case string(fv1.ExecutorTypeContainer):
 		executorType = fv1.ExecutorTypeContainer
 	default:
-		err = errors.Errorf("executor type must be one of '%v', '%v' or '%v'", fv1.ExecutorTypePoolmgr, fv1.ExecutorTypeNewdeploy, fv1.ExecutorTypeContainer)
+		err = fmt.Errorf("executor type must be one of '%v', '%v' or '%v'", fv1.ExecutorTypePoolmgr, fv1.ExecutorTypeNewdeploy, fv1.ExecutorTypeContainer)
 	}
 	return executorType, err
 }
@@ -501,7 +501,7 @@ func getExecutionStrategy(fnExecutor fv1.ExecutorType, input cli.Input) (strateg
 	if input.IsSet(flagkey.FnSpecializationTimeout) {
 		specializationTimeout = input.Int(flagkey.FnSpecializationTimeout)
 		if specializationTimeout < fv1.DefaultSpecializationTimeOut {
-			return nil, errors.Errorf("%v must be greater than or equal to 120 seconds", flagkey.FnSpecializationTimeout)
+			return nil, fmt.Errorf("%v must be greater than or equal to 120 seconds", flagkey.FnSpecializationTimeout)
 		}
 	}
 
@@ -529,7 +529,7 @@ func getExecutionStrategy(fnExecutor fv1.ExecutorType, input cli.Input) (strateg
 		if input.IsSet(flagkey.ReplicasMaxscale) {
 			maxScale = input.Int(flagkey.ReplicasMaxscale)
 			if maxScale <= 0 {
-				return nil, errors.Errorf("%v must be greater than 0", flagkey.ReplicasMaxscale)
+				return nil, fmt.Errorf("%v must be greater than 0", flagkey.ReplicasMaxscale)
 			}
 		}
 
@@ -573,7 +573,7 @@ func updateExecutionStrategy(input cli.Input, existingExecutionStrategy *fv1.Exe
 		case string(fv1.ExecutorTypeContainer):
 			fnExecutor = fv1.ExecutorTypeContainer
 		default:
-			return nil, errors.Errorf("executor type must be one of '%v', %v or '%v'", fv1.ExecutorTypePoolmgr, fv1.ExecutorTypeNewdeploy, fv1.ExecutorTypeContainer)
+			return nil, fmt.Errorf("executor type must be one of '%v', %v or '%v'", fv1.ExecutorTypePoolmgr, fv1.ExecutorTypeNewdeploy, fv1.ExecutorTypeContainer)
 		}
 	}
 
@@ -582,7 +582,7 @@ func updateExecutionStrategy(input cli.Input, existingExecutionStrategy *fv1.Exe
 	if input.IsSet(flagkey.FnSpecializationTimeout) {
 		specializationTimeout = input.Int(flagkey.FnSpecializationTimeout)
 		if specializationTimeout < fv1.DefaultSpecializationTimeOut {
-			return nil, errors.Errorf("%v must be greater than or equal to 120 seconds", flagkey.FnSpecializationTimeout)
+			return nil, fmt.Errorf("%v must be greater than or equal to 120 seconds", flagkey.FnSpecializationTimeout)
 		}
 	} else {
 		if specializationTimeout < fv1.DefaultSpecializationTimeOut {
@@ -618,7 +618,7 @@ func updateExecutionStrategy(input cli.Input, existingExecutionStrategy *fv1.Exe
 		if input.IsSet(flagkey.ReplicasMaxscale) {
 			maxScale = input.Int(flagkey.ReplicasMaxscale)
 			if maxScale <= 0 {
-				return nil, errors.Errorf("%v must be greater than 0", flagkey.ReplicasMaxscale)
+				return nil, fmt.Errorf("%v must be greater than 0", flagkey.ReplicasMaxscale)
 			}
 		} else {
 			if maxScale <= 0 {
@@ -655,7 +655,7 @@ func updateExecutionStrategy(input cli.Input, existingExecutionStrategy *fv1.Exe
 func getTargetCPU(input cli.Input) (int, error) {
 	targetCPU := input.Int(flagkey.RuntimeTargetcpu)
 	if targetCPU <= 0 || targetCPU > 100 {
-		return 0, errors.Errorf("%v must be a value between 1 - 100", flagkey.RuntimeTargetcpu)
+		return 0, fmt.Errorf("%v must be a value between 1 - 100", flagkey.RuntimeTargetcpu)
 	}
 	return targetCPU, nil
 }

pkg/fission-cli/cmd/function/delete.go

@@ -19,7 +19,6 @@ package function
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -40,7 +39,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) error {
 
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 	m := &metav1.ObjectMeta{
 		Name:      input.String(flagkey.FnName),
@@ -52,7 +51,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) error {
 		if input.Bool(flagkey.IgnoreNotFound) && util.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(err, fmt.Sprintf("delete function '%s'", m.Name))
+		return fmt.Errorf("delete function '%s': %w", m.Name, err)
 	}
 
 	fmt.Printf("function '%s' deleted\n", m.Name)

pkg/fission-cli/cmd/function/get.go

@@ -17,9 +17,9 @@ limitations under the License.
 package function
 
 import (
+	"fmt"
 	"os"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -38,16 +38,16 @@ func Get(input cli.Input) error {
 func (opts *GetSubCommand) do(input cli.Input) error {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in get function ")
+		return fmt.Errorf("error in get function : %w", err)
 	}
 	fn, err := opts.Client().FissionClientSet.CoreV1().Functions(namespace).Get(input.Context(), input.String(flagkey.FnName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting function")
+		return fmt.Errorf("error getting function: %w", err)
 	}
 
 	pkg, err := opts.Client().FissionClientSet.CoreV1().Packages(fn.Spec.Package.PackageRef.Namespace).Get(input.Context(), fn.Spec.Package.PackageRef.Name, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting package")
+		return fmt.Errorf("error getting package: %w", err)
 	}
 
 	os.Stdout.Write(pkg.Spec.Deployment.Literal)

pkg/fission-cli/cmd/function/getmeta.go

@@ -19,7 +19,6 @@ package function
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -38,12 +37,12 @@ func GetMeta(input cli.Input) error {
 func (opts *GetMetaSubCommand) do(input cli.Input) error {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in getting meta function ")
+		return fmt.Errorf("error in getting meta function : %w", err)
 	}
 
 	fn, err := opts.Client().FissionClientSet.CoreV1().Functions(namespace).Get(input.Context(), input.String(flagkey.FnName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting function")
+		return fmt.Errorf("error getting function: %w", err)
 	}
 
 	fmt.Printf("Name: %v\n", fn.ObjectMeta.Name)

pkg/fission-cli/cmd/function/list.go

@@ -22,7 +22,6 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -41,7 +40,7 @@ func List(input cli.Input) error {
 func (opts *ListSubCommand) do(input cli.Input) error {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in listing function ")
+		return fmt.Errorf("error in listing function : %w", err)
 	}
 
 	if input.Bool(flagkey.AllNamespaces) {
@@ -50,7 +49,7 @@ func (opts *ListSubCommand) do(input cli.Input) error {
 	fns, err := opts.Client().FissionClientSet.CoreV1().Functions(namespace).List(input.Context(), metav1.ListOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, "error listing functions")
+		return fmt.Errorf("error listing functions: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/function/log.go

@@ -19,11 +19,11 @@ package function
 import (
 	"bytes"
 	"context"
+	"fmt"
 	"io"
 	"os"
 	"time"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -44,7 +44,7 @@ func Log(input cli.Input) error {
 func (opts *LogSubCommand) do(input cli.Input) error {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in logs for function ")
+		return fmt.Errorf("error in logs for function : %w", err)
 	}
 
 	dbType := input.String(flagkey.FnLogDBType)
@@ -60,7 +60,7 @@ func (opts *LogSubCommand) do(input cli.Input) error {
 
 	f, err := opts.Client().FissionClientSet.CoreV1().Functions(namespace).Get(input.Context(), input.String(flagkey.FnName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting function")
+		return fmt.Errorf("error getting function: %w", err)
 	}
 
 	logDBOptions := logdb.LogDBOptions{
@@ -70,7 +70,7 @@ func (opts *LogSubCommand) do(input cli.Input) error {
 	// request the controller to establish a proxy server to the database.
 	logDB, err := logdb.GetLogDB(dbType, input.Context(), logDBOptions)
 	if err != nil {
-		return errors.Wrapf(err, "failed to get log from %s", dbType)
+		return fmt.Errorf("failed to get log from %s: %w", dbType, err)
 	}
 
 	requestChan := make(chan struct{})

pkg/fission-cli/cmd/function/pods.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 
@@ -45,12 +44,12 @@ func (opts *ListPodsSubCommand) do(input cli.Input) error {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 
 	if err != nil {
-		return errors.Wrap(err, "error in finding pod for function ")
+		return fmt.Errorf("error in finding pod for function : %w", err)
 	}
 	// validate function
 	_, err = opts.Client().FissionClientSet.CoreV1().Functions(namespace).Get(input.Context(), input.String(flagkey.FnName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting function")
+		return fmt.Errorf("error getting function: %w", err)
 	}
 
 	selector := map[string]string{
@@ -64,7 +63,7 @@ func (opts *ListPodsSubCommand) do(input cli.Input) error {
 		LabelSelector: labels.Set(selector).AsSelector().String(),
 	})
 	if err != nil {
-		return errors.Wrap(err, "error listing environments")
+		return fmt.Errorf("error listing environments: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)

pkg/fission-cli/cmd/function/run_container.go

@@ -20,7 +20,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	apiv1 "k8s.io/api/core/v1"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -57,7 +58,7 @@ func (opts *RunContainerSubCommand) complete(input cli.Input) error {
 
 	_, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in running container for function ")
+		return fmt.Errorf("error in running container for function : %w", err)
 	}
 
 	// user wants a spec, create a yaml file with package and function
@@ -80,7 +81,7 @@ func (opts *RunContainerSubCommand) complete(input cli.Input) error {
 
 	fnTimeout := input.Int(flagkey.FnExecutionTimeout)
 	if fnTimeout <= 0 {
-		return errors.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
+		return fmt.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
 	}
 
 	fnIdleTimeout := input.Int(flagkey.FnIdleTimeout)
@@ -132,7 +133,7 @@ func (opts *RunContainerSubCommand) complete(input cli.Input) error {
 					if kerrors.IsNotFound(err) {
 						console.Warn(fmt.Sprintf("Secret %s not found in Namespace: %s. Secret needs to be present in the same namespace as function", secretName, fnNamespace))
 					} else {
-						return errors.Wrapf(err, "error checking secret %s", secretName)
+						return fmt.Errorf("error checking secret %s: %w", secretName, err)
 					}
 				}
 			}
@@ -156,7 +157,7 @@ func (opts *RunContainerSubCommand) complete(input cli.Input) error {
 					if kerrors.IsNotFound(err) {
 						console.Warn(fmt.Sprintf("ConfigMap %s not found in Namespace: %s. ConfigMap needs to be present in the same namespace as function", cfgMapName, fnNamespace))
 					} else {
-						return errors.Wrapf(err, "error checking configmap %s", cfgMapName)
+						return fmt.Errorf("error checking configmap %s: %w", cfgMapName, err)
 					}
 				}
 			}
@@ -228,14 +229,14 @@ func (opts *RunContainerSubCommand) run(input cli.Input) error {
 	if input.Bool(flagkey.SpecSave) {
 		err := spec.SpecSave(*opts.function, opts.specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving function spec")
+			return fmt.Errorf("error saving function spec: %w", err)
 		}
 		return nil
 	}
 
 	_, err := opts.Client().FissionClientSet.CoreV1().Functions(opts.function.ObjectMeta.Namespace).Create(input.Context(), opts.function, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating function")
+		return fmt.Errorf("error creating function: %w", err)
 	}
 
 	fmt.Printf("function '%v' created\n", opts.function.ObjectMeta.Name)

pkg/fission-cli/cmd/function/test.go

@@ -27,7 +27,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.opentelemetry.io/otel"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -53,12 +54,12 @@ func (opts *TestSubCommand) do(input cli.Input) error {
 	fnName := input.String(flagkey.FnName)
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in testing function ")
+		return fmt.Errorf("error in testing function : %w", err)
 	}
 
 	function, err := opts.Client().FissionClientSet.CoreV1().Functions(namespace).Get(input.Context(), fnName, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("read function '%s'", fnName))
+		return fmt.Errorf("read function '%s': %w", fnName, err)
 	}
 
 	m := &metav1.ObjectMeta{
@@ -68,7 +69,7 @@ func (opts *TestSubCommand) do(input cli.Input) error {
 
 	routerURL, err := util.GetRouterURL(input.Context(), opts.Client())
 	if err != nil {
-		return errors.Wrap(err, "error getting router URL")
+		return fmt.Errorf("error getting router URL: %w", err)
 	}
 	fnURI := util.UrlForFunction(m.Name, m.Namespace)
 	if input.IsSet(flagkey.FnSubPath) {
@@ -146,7 +147,7 @@ func (opts *TestSubCommand) do(input cli.Input) error {
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return errors.Wrap(err, "error reading response from function")
+		return fmt.Errorf("error reading response from function: %w", err)
 	}
 
 	if resp.StatusCode < 400 {
@@ -186,7 +187,7 @@ func doHTTPRequest(ctx context.Context, url string, headers []string, method, bo
 
 	req, err := http.NewRequest(method, url, strings.NewReader(body))
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating HTTP request")
+		return nil, fmt.Errorf("error creating HTTP request: %w", err)
 	}
 
 	accesstoken, ok := os.LookupEnv(util.FISSION_AUTH_TOKEN)
@@ -213,7 +214,7 @@ func doHTTPRequest(ctx context.Context, url string, headers []string, method, bo
 	hc := &http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)}
 	resp, err := hc.Do(req.WithContext(ctx))
 	if err != nil {
-		return nil, errors.Wrap(err, "error executing HTTP request")
+		return nil, fmt.Errorf("error executing HTTP request: %w", err)
 	}
 
 	if console.Verbosity >= 2 {

pkg/fission-cli/cmd/function/update.go

@@ -19,7 +19,6 @@ package function
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -55,7 +54,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) error {
 	fnName := input.String(flagkey.FnName)
 	_, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in updating function ")
+		return fmt.Errorf("error in updating function : %w", err)
 	}
 	if input.Bool(flagkey.SpecSave) {
 		opts.specFile = fmt.Sprintf("function-%s.yaml", fnName)
@@ -63,7 +62,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) error {
 
 	function, err := opts.Client().FissionClientSet.CoreV1().Functions(fnNamespace).Get(input.Context(), input.String(flagkey.FnName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("read function '%v'", fnName))
+		return fmt.Errorf("read function '%v': %w", fnName, err)
 	}
 
 	envName := input.String(flagkey.FnEnvironmentName)
@@ -135,7 +134,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) error {
 	if input.IsSet(flagkey.FnExecutionTimeout) {
 		fnTimeout := input.Int(flagkey.FnExecutionTimeout)
 		if fnTimeout <= 0 {
-			return errors.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
+			return fmt.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
 		}
 		function.Spec.FunctionTimeout = fnTimeout
 	}
@@ -184,23 +183,23 @@ func (opts *UpdateSubCommand) complete(input cli.Input) error {
 
 	pkg, err := opts.Client().FissionClientSet.CoreV1().Packages(fnNamespace).Get(input.Context(), pkgName, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("read package '%v.%v'. Pkg should be present in the same ns as the function", pkgName, fnNamespace))
+		return fmt.Errorf("read package '%v.%v'. Pkg should be present in the same ns as the function: %w", pkgName, fnNamespace, err)
 	}
 
 	forceUpdate := input.Bool(flagkey.PkgForce)
 
 	fnList, err := _package.GetFunctionsByPackage(input.Context(), opts.Client(), pkg.ObjectMeta.Name, pkg.ObjectMeta.Namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting function list")
+		return fmt.Errorf("error getting function list: %w", err)
 	}
 
 	if !forceUpdate && len(fnList) > 1 {
-		return errors.Errorf("Package is used by multiple functions, use --%v to force update", flagkey.PkgForce)
+		return fmt.Errorf("package is used by multiple functions, use --%v to force update", flagkey.PkgForce)
 	}
 
 	newPkgMeta, err := _package.UpdatePackage(input, opts.Client(), opts.specFile, pkg)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error updating package '%v'", pkgName))
+		return fmt.Errorf("error updating package '%v': %w", pkgName, err)
 	}
 
 	// the package resource version of function has been changed,
@@ -217,7 +216,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) error {
 		}
 		err = _package.UpdateFunctionPackageResourceVersion(input.Context(), opts.Client(), newPkgMeta, fns...)
 		if err != nil {
-			return errors.Wrap(err, "error updating function package reference resource version")
+			return fmt.Errorf("error updating function package reference resource version: %w", err)
 		}
 	}
 
@@ -255,13 +254,13 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 		}
 		err = spec.SpecSave(*opts.function, opts.specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving function spec")
+			return fmt.Errorf("error saving function spec: %w", err)
 		}
 		return nil
 	}
 	_, err := opts.Client().FissionClientSet.CoreV1().Functions(opts.function.Namespace).Update(input.Context(), opts.function, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating function")
+		return fmt.Errorf("error updating function: %w", err)
 	}
 
 	fmt.Printf("Function '%v' updated\n", opts.function.ObjectMeta.Name)

pkg/fission-cli/cmd/function/update_container.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
 	apiv1 "k8s.io/api/core/v1"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -55,13 +54,13 @@ func (opts *UpdateContainerSubCommand) complete(input cli.Input) error {
 
 	_, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in updating container for function ")
+		return fmt.Errorf("error in updating container for function : %w", err)
 	}
 
 	function, err := opts.Client().FissionClientSet.CoreV1().Functions(fnNamespace).Get(input.Context(), input.String(flagkey.FnName), metav1.GetOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("read function '%v'", fnName))
+		return fmt.Errorf("read function '%v': %w", fnName, err)
 	}
 	if fv1.ExecutorTypeContainer != function.Spec.InvokeStrategy.ExecutionStrategy.ExecutorType {
 		return fmt.Errorf("executor type for function is not %s", fv1.ExecutorTypeContainer)
@@ -122,7 +121,7 @@ func (opts *UpdateContainerSubCommand) complete(input cli.Input) error {
 	if input.IsSet(flagkey.FnExecutionTimeout) {
 		fnTimeout := input.Int(flagkey.FnExecutionTimeout)
 		if fnTimeout <= 0 {
-			return errors.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
+			return fmt.Errorf("--%v must be greater than 0", flagkey.FnExecutionTimeout)
 		}
 		function.Spec.FunctionTimeout = fnTimeout
 	}
@@ -146,7 +145,7 @@ func (opts *UpdateContainerSubCommand) complete(input cli.Input) error {
 	function.Spec.Resources = *resReqs
 
 	if len(function.Spec.PodSpec.Containers) > 1 {
-		return errors.Errorf("function %s has more than one container, only one container is supported", fnName)
+		return fmt.Errorf("function %s has more than one container, only one container is supported", fnName)
 	}
 	container := &function.Spec.PodSpec.Containers[0]
 	if imageName != "" {
@@ -154,7 +153,7 @@ func (opts *UpdateContainerSubCommand) complete(input cli.Input) error {
 	}
 	if port != 0 {
 		if len(container.Ports) > 1 {
-			return errors.Errorf("function %s has more than one port, only one port is supported", fnName)
+			return fmt.Errorf("function %s has more than one port, only one port is supported", fnName)
 		}
 		container.Ports = []apiv1.ContainerPort{
 			{
@@ -186,7 +185,7 @@ func (opts *UpdateContainerSubCommand) complete(input cli.Input) error {
 func (opts *UpdateContainerSubCommand) run(input cli.Input) error {
 	_, err := opts.Client().FissionClientSet.CoreV1().Functions(opts.function.Namespace).Update(input.Context(), opts.function, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating function")
+		return fmt.Errorf("error updating function: %w", err)
 	}
 
 	return nil

pkg/fission-cli/cmd/httptrigger/create.go

@@ -22,7 +22,8 @@ import (
 	"os"
 	"strings"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -75,7 +76,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 	userProvidedNS, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	triggerUrl := input.String(flagkey.HtUrl)
@@ -125,7 +126,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 		specIgnore := util.GetSpecIgnore(input)
 		fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("error reading spec in '%v'", specDir))
+			return fmt.Errorf("error reading spec in '%v': %w", specDir, err)
 		}
 		for _, fn := range functionList {
 			exists, err := fr.ExistsInSpecs(fv1.Function{
@@ -167,7 +168,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 		input.StringSlice(flagkey.HtIngressAnnotation), input.String(flagkey.HtIngressRule),
 		input.String(flagkey.HtIngressTLS), fallbackURL, nil)
 	if err != nil {
-		return errors.Wrap(err, "error parsing ingress configuration")
+		return fmt.Errorf("error parsing ingress configuration: %w", err)
 	}
 
 	opts.trigger = &fv1.HTTPTrigger{
@@ -198,7 +199,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("route-%v.yaml", opts.trigger.ObjectMeta.Name)
 		err := spec.SpecSave(*opts.trigger, specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving HTTP trigger spec")
+			return fmt.Errorf("error saving HTTP trigger spec: %w", err)
 		}
 		return nil
 	}
@@ -206,12 +207,12 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	// Ensure we don't have a duplicate HTTP route defined (same URL and method)
 	err := util.CheckHTTPTriggerDuplicates(input.Context(), opts.Client(), opts.trigger)
 	if err != nil {
-		return errors.Wrap(err, "Error while creating HTTP Trigger")
+		return fmt.Errorf("Error while creating HTTP Trigger: %w", err)
 	}
 
 	_, err = opts.Client().FissionClientSet.CoreV1().HTTPTriggers(opts.trigger.Namespace).Create(input.Context(), opts.trigger, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "create HTTP trigger")
+		return fmt.Errorf("create HTTP trigger: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' created\n", opts.trigger.ObjectMeta.Name)

pkg/fission-cli/cmd/httptrigger/delete.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -53,14 +52,14 @@ func (opts *DeleteSubCommand) complete(input cli.Input) (err error) {
 	opts.triggerName = input.String(flagkey.HtName)
 	opts.functionName = input.String(flagkey.HtFnName)
 	if len(opts.triggerName) == 0 && len(opts.functionName) == 0 {
-		return errors.Errorf("need --%v or --%v", flagkey.HtName, flagkey.HtFnName)
+		return fmt.Errorf("need --%v or --%v", flagkey.HtName, flagkey.HtFnName)
 	} else if len(opts.triggerName) > 0 && len(opts.functionName) > 0 {
-		return errors.Errorf("need either of --%v or --%v and not both arguments", flagkey.HtName, flagkey.HtFnName)
+		return fmt.Errorf("need either of --%v or --%v and not both arguments", flagkey.HtName, flagkey.HtFnName)
 	}
 
 	_, opts.namespace, err = opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 	return nil
 }
@@ -68,7 +67,7 @@ func (opts *DeleteSubCommand) complete(input cli.Input) (err error) {
 func (opts *DeleteSubCommand) run(input cli.Input) error {
 	triggers, err := opts.Client().FissionClientSet.CoreV1().HTTPTriggers(opts.namespace).List(input.Context(), metav1.ListOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting HTTP trigger list")
+		return fmt.Errorf("error getting HTTP trigger list: %w", err)
 	}
 
 	var triggersToDelete []string
@@ -99,7 +98,7 @@ func (opts *DeleteSubCommand) run(input cli.Input) error {
 		if input.Bool(flagkey.IgnoreNotFound) && util.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(errs.ErrorOrNil(), "error deleting trigger(s)")
+		return fmt.Errorf("error deleting trigger(s): %w", errs.ErrorOrNil())
 	}
 
 	return nil

pkg/fission-cli/cmd/httptrigger/get.go

@@ -22,7 +22,6 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -46,12 +45,12 @@ func (opts *GetSubCommand) do(input cli.Input) error {
 func (opts *GetSubCommand) run(input cli.Input) (err error) {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	ht, err := opts.Client().FissionClientSet.CoreV1().HTTPTriggers(namespace).Get(input.Context(), input.String(flagkey.HtName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting http trigger")
+		return fmt.Errorf("error getting http trigger: %w", err)
 	}
 
 	printHtSummary([]fv1.HTTPTrigger{*ht})

pkg/fission-cli/cmd/httptrigger/list.go

@@ -17,7 +17,8 @@ limitations under the License.
 package httptrigger
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
+
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -42,7 +43,7 @@ func (opts *ListSubCommand) run(input cli.Input) (err error) {
 
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	if input.Bool(flagkey.AllNamespaces) {
@@ -51,7 +52,7 @@ func (opts *ListSubCommand) run(input cli.Input) (err error) {
 	hts, err := opts.Client().FissionClientSet.CoreV1().HTTPTriggers(namespace).List(input.Context(), v1.ListOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, "error listing HTTP triggers")
+		return fmt.Errorf("error listing HTTP triggers: %w", err)
 	}
 
 	filterFunctionName := input.String(flagkey.HtFnName)

pkg/fission-cli/cmd/httptrigger/update.go

@@ -20,7 +20,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -54,12 +55,12 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 
 	_, triggerNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	ht, err := opts.Client().FissionClientSet.CoreV1().HTTPTriggers(triggerNamespace).Get(input.Context(), htName, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting HTTP trigger")
+		return fmt.Errorf("error getting HTTP trigger: %w", err)
 	}
 
 	triggerUrl := input.String(flagkey.HtUrl)
@@ -113,7 +114,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 		// set function reference
 		functionRef, err := setHtFunctionRef(functionList, functionWeightsList)
 		if err != nil {
-			return errors.Wrap(err, "error setting function weight")
+			return fmt.Errorf("error setting function weight: %w", err)
 		}
 
 		ht.Spec.FunctionReference = *functionRef
@@ -138,7 +139,7 @@ func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 			input.StringSlice(flagkey.HtIngressAnnotation), input.String(flagkey.HtIngressRule),
 			input.String(flagkey.HtIngressTLS), fallbackURL, &ht.Spec.IngressConfig)
 		if err != nil {
-			return errors.Wrap(err, "error parsing ingress configuration")
+			return fmt.Errorf("error parsing ingress configuration: %w", err)
 		}
 		ht.Spec.IngressConfig = *ingress
 	}
@@ -157,18 +158,18 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("route-%s.yaml", opts.trigger.ObjectMeta.Name)
 		err = spec.SpecSave(*opts.trigger, specFile, true)
 		if err != nil {
-			return errors.Wrap(err, "error saving HTTP trigger spec")
+			return fmt.Errorf("error saving HTTP trigger spec: %w", err)
 		}
 		return nil
 	}
 	err := util.CheckHTTPTriggerDuplicates(input.Context(), opts.Client(), opts.trigger)
 	if err != nil {
-		return errors.Wrap(err, "Error while creating HTTP Trigger")
+		return fmt.Errorf("Error while creating HTTP Trigger: %w", err)
 	}
 
 	_, err = opts.Client().FissionClientSet.CoreV1().HTTPTriggers(opts.trigger.ObjectMeta.Namespace).Update(input.Context(), opts.trigger, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating the HTTP trigger")
+		return fmt.Errorf("error updating the HTTP trigger: %w", err)
 	}
 	fmt.Printf("trigger '%v' updated\n", opts.trigger.ObjectMeta.Name)
 	return nil

pkg/fission-cli/cmd/kubewatch/create.go

@@ -19,7 +19,6 @@ package kubewatch
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -59,7 +58,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.KwNamespace)
 	if err != nil {
-		return errors.Wrap(err, "error in listing function ")
+		return fmt.Errorf("error in listing function : %w", err)
 	}
 
 	objType := input.String(flagkey.KwObjType)
@@ -69,7 +68,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 		specIgnore := util.GetSpecIgnore(input)
 		fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("error reading spec in '%v'", specDir))
+			return fmt.Errorf("error reading spec in '%v': %w", specDir, err)
 		}
 
 		exists, err := fr.ExistsInSpecs(fv1.Function{
@@ -117,14 +116,14 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("kubewatch-%v.yaml", opts.watcher.ObjectMeta.Name)
 		err := spec.SpecSave(*opts.watcher, specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving kubewatch spec")
+			return fmt.Errorf("error saving kubewatch spec: %w", err)
 		}
 		return nil
 	}
 
 	_, err := opts.Client().FissionClientSet.CoreV1().KubernetesWatchTriggers(opts.watcher.ObjectMeta.Namespace).Create(input.Context(), opts.watcher, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating kubewatch")
+		return fmt.Errorf("error creating kubewatch: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' created\n", opts.watcher.ObjectMeta.Name)

pkg/fission-cli/cmd/kubewatch/delete.go

@@ -19,7 +19,6 @@ package kubewatch
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -50,7 +49,7 @@ func (opts *DeleteSubCommand) complete(input cli.Input) (err error) {
 	opts.name = input.String(flagkey.KwName)
 	_, opts.namespace, err = opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting kubewatch")
+		return fmt.Errorf("error in deleting kubewatch: %w", err)
 	}
 	return nil
 }
@@ -61,7 +60,7 @@ func (opts *DeleteSubCommand) run(input cli.Input) error {
 		if input.Bool(flagkey.IgnoreNotFound) && util.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(err, "error deleting kubewatch")
+		return fmt.Errorf("error deleting kubewatch: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' deleted\n", opts.name)

pkg/fission-cli/cmd/kubewatch/list.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	v1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -50,7 +49,7 @@ func (opts *ListSubCommand) do(input cli.Input) error {
 func (opts *ListSubCommand) complete(input cli.Input) (err error) {
 	_, opts.namespace, err = opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error listing kubewatchers")
+		return fmt.Errorf("error listing kubewatchers: %w", err)
 	}
 	return nil
 }
@@ -63,7 +62,7 @@ func (opts *ListSubCommand) run(input cli.Input) (err error) {
 	ws, err = opts.Client().FissionClientSet.CoreV1().KubernetesWatchTriggers(opts.namespace).List(input.Context(), metav1.ListOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, "error listing kubewatchers")
+		return fmt.Errorf("error listing kubewatchers: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/mqtrigger/create.go

@@ -19,7 +19,8 @@ package mqtrigger
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -60,7 +61,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 
 	userProvidedNS, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	mqtKind := input.String(flagkey.MqtKind)
@@ -130,7 +131,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) error {
 		specIgnore := util.GetSpecIgnore(input)
 		fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("error reading spec in '%v'", specDir))
+			return fmt.Errorf("error reading spec in '%v': %w", specDir, err)
 		}
 
 		exists, err := fr.ExistsInSpecs(fv1.Function{
@@ -201,14 +202,14 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("mqtrigger-%v.yaml", opts.trigger.ObjectMeta.Name)
 		err := spec.SpecSave(*opts.trigger, specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving message queue trigger spec")
+			return fmt.Errorf("error saving message queue trigger spec: %w", err)
 		}
 		return nil
 	}
 
 	_, err := opts.Client().FissionClientSet.CoreV1().MessageQueueTriggers(opts.trigger.ObjectMeta.Namespace).Create(input.Context(), opts.trigger, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "create message queue trigger")
+		return fmt.Errorf("create message queue trigger: %w", err)
 	}
 
 	fmt.Printf("trigger '%s' created\n", opts.trigger.ObjectMeta.Name)
@@ -218,7 +219,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 func checkMQTopicAvailability(mqType fv1.MessageQueueType, mqtKind string, topics ...string) error {
 	for _, t := range topics {
 		if len(t) > 0 && !validator.IsValidTopic((string)(mqType), t, mqtKind) {
-			return errors.Errorf("invalid topic for %s: %s", mqType, t)
+			return fmt.Errorf("invalid topic for %s: %s", mqType, t)
 		}
 	}
 	return nil

pkg/fission-cli/cmd/mqtrigger/delete.go

@@ -19,7 +19,6 @@ package mqtrigger
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -49,7 +48,7 @@ func (opts *DeleteSubCommand) complete(input cli.Input) (err error) {
 
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	opts.metadata = &metav1.ObjectMeta{
@@ -65,7 +64,7 @@ func (opts *DeleteSubCommand) run(input cli.Input) error {
 		if input.Bool(flagkey.IgnoreNotFound) && kerrors.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(err, "error deleting message queue trigger")
+		return fmt.Errorf("error deleting message queue trigger: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' deleted\n", opts.metadata.Name)

pkg/fission-cli/cmd/mqtrigger/list.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -49,7 +48,7 @@ func (opts *ListSubCommand) do(input cli.Input) error {
 func (opts *ListSubCommand) complete(input cli.Input) (err error) {
 	_, opts.namespace, err = opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 	return nil
 }
@@ -62,7 +61,7 @@ func (opts *ListSubCommand) run(input cli.Input) (err error) {
 	mqts, err := opts.Client().FissionClientSet.CoreV1().MessageQueueTriggers(opts.namespace).List(input.Context(), metav1.ListOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, "error listing message queue triggers")
+		return fmt.Errorf("error listing message queue triggers: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/mqtrigger/update.go

@@ -19,7 +19,8 @@ package mqtrigger
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -51,12 +52,12 @@ func (opts *UpdateSubCommand) do(input cli.Input) error {
 func (opts *UpdateSubCommand) complete(input cli.Input) (err error) {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	mqt, err := opts.Client().FissionClientSet.CoreV1().MessageQueueTriggers(namespace).Get(input.Context(), input.String(flagkey.MqtName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting message queue trigger")
+		return fmt.Errorf("error getting message queue trigger: %w", err)
 	}
 
 	topic := input.String(flagkey.MqtTopic)
@@ -158,13 +159,13 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("mqtrigger-%s.yaml", opts.trigger.ObjectMeta.Name)
 		err = spec.SpecSave(*opts.trigger, specFile, true)
 		if err != nil {
-			return errors.Wrap(err, "error saving message queue trigger spec")
+			return fmt.Errorf("error saving message queue trigger spec: %w", err)
 		}
 		return nil
 	}
 	_, err := opts.Client().FissionClientSet.CoreV1().MessageQueueTriggers(opts.trigger.ObjectMeta.Namespace).Update(input.Context(), opts.trigger, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating message queue trigger")
+		return fmt.Errorf("error updating message queue trigger: %w", err)
 	}
 
 	fmt.Printf("message queue trigger '%v' updated\n", opts.trigger.ObjectMeta.Name)

pkg/fission-cli/cmd/package/create.go

@@ -23,7 +23,6 @@ import (
 	"time"
 
 	"github.com/dchest/uniuri"
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -56,7 +55,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	pkgName := input.String(flagkey.PkgName)
 	if len(pkgName) == 0 {
 		if input.Bool(flagkey.SpecSave) && len(input.String(flagkey.PkgName)) == 0 {
-			return errors.Errorf("--%v is necessary when creating spec file", flagkey.PkgName)
+			return fmt.Errorf("--%v is necessary when creating spec file", flagkey.PkgName)
 		} else {
 			console.Warn(fmt.Sprintf("--%v will be soon marked as required flag, see 'help' for details", flagkey.HtName))
 		}
@@ -83,7 +82,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	}
 
 	if len(srcArchiveFiles) == 0 && len(deployArchiveFiles) == 0 {
-		return errors.Errorf("need --%v or --%v or --%v argument", flagkey.PkgCode, flagkey.PkgSrcArchive, flagkey.PkgDeployArchive)
+		return fmt.Errorf("need --%v or --%v or --%v argument", flagkey.PkgCode, flagkey.PkgSrcArchive, flagkey.PkgDeployArchive)
 	}
 
 	var specDir, specFile string
@@ -91,14 +90,14 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	if input.Bool(flagkey.SpecSave) {
 		// since package CRD created using --spec, not validate by k8s. So we need to validate it and make sure package name is not more than 63 characters.
 		if len(pkgName) > 63 {
-			return errors.Errorf("error creating package: package name %v, must be no more than 63 characters", pkgName)
+			return fmt.Errorf("error creating package: package name %v, must be no more than 63 characters", pkgName)
 		}
 
 		specDir = util.GetSpecDir(input)
 		specIgnore := util.GetSpecIgnore(input)
 		fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("error reading spec in '%v'", specDir))
+			return fmt.Errorf("error reading spec in '%v': %w", specDir, err)
 		}
 		exists, err := fr.ExistsInSpecs(fv1.Environment{
 			ObjectMeta: metav1.ObjectMeta{
@@ -155,7 +154,7 @@ func CreatePackage(input cli.Input, client cmd.Client, pkgName string, pkgNamesp
 		}
 		deployment, err := CreateArchive(client, input, deployArchiveFiles, noZip, insecure, deployChecksum, specDir, specFile)
 		if err != nil {
-			return nil, errors.Wrap(err, "error creating deploy archive")
+			return nil, fmt.Errorf("error creating deploy archive: %w", err)
 		}
 		pkgSpec.Deployment = *deployment
 		if len(pkgName) == 0 {
@@ -165,7 +164,7 @@ func CreatePackage(input cli.Input, client cmd.Client, pkgName string, pkgNamesp
 	if len(srcArchiveFiles) > 0 {
 		source, err := CreateArchive(client, input, srcArchiveFiles, false, insecure, srcChecksum, specDir, specFile)
 		if err != nil {
-			return nil, errors.Wrap(err, "error creating source archive")
+			return nil, fmt.Errorf("error creating source archive: %w", err)
 		}
 		pkgSpec.Source = *source
 		pkgStatus = fv1.BuildStatusPending // set package build status to pending
@@ -202,7 +201,7 @@ func CreatePackage(input cli.Input, client cmd.Client, pkgName string, pkgNamesp
 		// if a package with the same spec exists, don't create a new spec file
 		fr, err := spec.ReadSpecs(util.GetSpecDir(input), util.GetSpecIgnore(input), false)
 		if err != nil {
-			return nil, errors.Wrap(err, "error reading specs")
+			return nil, fmt.Errorf("error reading specs: %w", err)
 		}
 
 		obj := fr.SpecExists(pkg, true, true)
@@ -214,7 +213,7 @@ func CreatePackage(input cli.Input, client cmd.Client, pkgName string, pkgNamesp
 
 		err = spec.SpecSave(*pkg, specFile, false)
 		if err != nil {
-			return nil, errors.Wrap(err, "error saving package spec")
+			return nil, fmt.Errorf("error saving package spec: %w", err)
 		}
 		return &pkg.ObjectMeta, nil
 	} else {
@@ -222,7 +221,7 @@ func CreatePackage(input cli.Input, client cmd.Client, pkgName string, pkgNamesp
 
 		pkgMetadata, err := client.FissionClientSet.CoreV1().Packages(pkgNamespace).Create(input.Context(), pkg, metav1.CreateOptions{})
 		if err != nil {
-			return nil, errors.Wrap(err, "error creating package")
+			return nil, fmt.Errorf("error creating package: %w", err)
 		}
 		fmt.Printf("Package '%v' created\n", pkgMetadata.GetName())
 		return &pkgMetadata.ObjectMeta, nil

pkg/fission-cli/cmd/package/delete.go

@@ -20,7 +20,8 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -61,7 +62,7 @@ func (opts *DeleteSubCommand) complete(input cli.Input) (err error) {
 	opts.force = input.Bool(flagkey.PkgForce)
 
 	if len(opts.name) == 0 && !opts.deleteOrphans {
-		return errors.Errorf("need --%v or --%v flag", flagkey.PkgName, flagkey.PkgOrphan)
+		return fmt.Errorf("need --%v or --%v flag", flagkey.PkgName, flagkey.PkgOrphan)
 	}
 
 	return nil
@@ -74,7 +75,7 @@ func (opts *DeleteSubCommand) run(input cli.Input) error {
 			if input.Bool(flagkey.IgnoreNotFound) && kerrors.IsNotFound(err) {
 				return nil
 			}
-			return errors.Wrap(err, "find package")
+			return fmt.Errorf("find package: %w", err)
 		}
 
 		fnList, err := GetFunctionsByPackage(input.Context(), opts.Client(), opts.name, opts.namespace)
@@ -96,7 +97,7 @@ func (opts *DeleteSubCommand) run(input cli.Input) error {
 	if opts.deleteOrphans {
 		err := deleteOrphanPkgs(input.Context(), opts.Client(), opts.namespace)
 		if err != nil {
-			return errors.Wrap(err, "deleting orphan packages")
+			return fmt.Errorf("deleting orphan packages: %w", err)
 		}
 		fmt.Println("Orphan packages deleted")
 	}
@@ -114,7 +115,7 @@ func deleteOrphanPkgs(ctx context.Context, client cmd.Client, pkgNamespace strin
 	for _, pkg := range pkgList.Items {
 		fnList, err := GetFunctionsByPackage(ctx, client, pkg.ObjectMeta.Name, pkgNamespace)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("get functions sharing package %s", pkg.ObjectMeta.Name))
+			return fmt.Errorf("get functions sharing package %v: %w", pkg.ObjectMeta.Name, err)
 		}
 		if len(fnList) == 0 {
 			err = deletePackage(ctx, client, pkg.ObjectMeta.Name, pkgNamespace)

pkg/fission-cli/cmd/package/get.go

@@ -18,10 +18,10 @@ package _package
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"os"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -88,7 +88,7 @@ func (opts *GetSubCommand) run(input cli.Input) error {
 
 		readCloser, err := pkgutil.DownloadStrorageURL(input.Context(), opts.Client(), archive.URL)
 		if err != nil {
-			return errors.Wrapf(err, "error downloading from storage service url: %s", archive.URL)
+			return fmt.Errorf("error downloading from storage service url: %s: %w", archive.URL, err)
 		}
 
 		defer readCloser.Close()

pkg/fission-cli/cmd/package/info.go

@@ -17,9 +17,9 @@ limitations under the License.
 package _package
 
 import (
+	"fmt"
 	"os"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -60,7 +60,7 @@ func (opts *InfoSubCommand) complete(input cli.Input) (err error) {
 func (opts *InfoSubCommand) run(input cli.Input) error {
 	pkg, err := opts.Client().FissionClientSet.CoreV1().Packages(opts.namespace).Get(input.Context(), opts.name, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrapf(err, "error finding package %s", opts.name)
+		return fmt.Errorf("error finding package %s: %w", opts.name, err)
 	}
 
 	pkgutil.PrintPackageSummary(os.Stdout, pkg)

pkg/fission-cli/cmd/package/list.go

@@ -23,7 +23,6 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"github.com/pkg/errors"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -87,7 +86,7 @@ func (opts *ListSubCommand) run(input cli.Input) (err error) {
 		if opts.listOrphans {
 			fnList, err := GetFunctionsByPackage(input.Context(), opts.Client(), pkg.ObjectMeta.Name, pkg.ObjectMeta.Namespace)
 			if err != nil {
-				return errors.Wrap(err, fmt.Sprintf("get functions sharing package %s", pkg.ObjectMeta.Name))
+				return fmt.Errorf("get functions sharing package %v: %w", pkg.ObjectMeta.Name, err)
 			}
 			if len(fnList) > 0 {
 				show = false

pkg/fission-cli/cmd/package/package.go

@@ -24,9 +24,10 @@ import (
 	"path/filepath"
 	"strings"
 
+	"errors"
+
 	"github.com/dchest/uniuri"
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -54,7 +55,7 @@ func CreateArchive(client cmd.Client, input cli.Input, includeFiles []string, no
 	if len(specFile) > 0 {
 		rootDir, err = filepath.Abs(specDir + "/..")
 		if err != nil {
-			return nil, errors.Wrapf(err, "error getting root directory of spec directory")
+			return nil, fmt.Errorf("error getting root directory of spec directory: %w", err)
 		}
 	}
 	errs := utils.MultiErrorWithFormat()
@@ -75,24 +76,24 @@ func CreateArchive(client cmd.Client, input cli.Input, includeFiles []string, no
 		// Get files from inputs as number of files decide next steps
 		absPath, err := filepath.Abs(path)
 		if err != nil {
-			errs = multierror.Append(errs, errors.Wrapf(err, "error converting path to the absolute path \"%v\"", path))
+			errs = multierror.Append(errs, fmt.Errorf("error converting path to the absolute path \"%v\": %w", path, err))
 			continue
 		}
 
 		if !strings.HasPrefix(absPath, rootDir) {
-			errs = multierror.Append(errs, errors.Errorf("The files (%v) should be put under the same parent directory (%v) of spec directory; otherwise, the archive will be empty when applying spec files", path, rootDir))
+			errs = multierror.Append(errs, fmt.Errorf("The files (%v) should be put under the same parent directory (%v) of spec directory; otherwise, the archive will be empty when applying spec files", path, rootDir))
 			continue
 		}
 
 		path := filepath.Join(rootDir, path)
 		files, err := utils.FindAllGlobs(path)
 		if err != nil {
-			errs = multierror.Append(errs, errors.Wrap(err, "error finding all globs"))
+			errs = multierror.Append(errs, fmt.Errorf("error finding all globs: %w", err))
 			continue
 		}
 
 		if len(files) == 0 {
-			errs = multierror.Append(errs, errors.Errorf("Error finding any files with path \"%v\"", path))
+			errs = multierror.Append(errs, fmt.Errorf("Error finding any files with path \"%v\"", path))
 		}
 	}
 
@@ -127,12 +128,12 @@ func CreateArchive(client cmd.Client, input cli.Input, includeFiles []string, no
 			file := filepath.Join(tmpDir, uuid.NewString())
 			err = utils.DownloadUrl(input.Context(), http.DefaultClient, fileURL, file)
 			if err != nil {
-				return nil, errors.Wrap(err, "error downloading file from the given URL")
+				return nil, fmt.Errorf("error downloading file from the given URL: %w", err)
 			}
 
 			csum, err = utils.GetFileChecksum(file)
 			if err != nil {
-				return nil, errors.Wrap(err, "error generating file SHA256 checksum")
+				return nil, fmt.Errorf("error generating file SHA256 checksum: %w", err)
 			}
 		}
 
@@ -160,7 +161,7 @@ func CreateArchive(client cmd.Client, input cli.Input, includeFiles []string, no
 			specIgnore := util.GetSpecIgnore(input)
 			fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 			if err != nil {
-				return nil, errors.Wrap(err, "error reading specs")
+				return nil, fmt.Errorf("error reading specs: %w", err)
 			}
 
 			obj := fr.SpecExists(aus, true, true)
@@ -172,7 +173,7 @@ func CreateArchive(client cmd.Client, input cli.Input, includeFiles []string, no
 				// save the uploadspec
 				err := spec.SpecSave(*aus, specFile, false)
 				if err != nil {
-					return nil, errors.Wrap(err, "error saving archive spec")
+					return nil, fmt.Errorf("error saving archive spec: %w", err)
 				}
 			}
 		}
@@ -208,14 +209,14 @@ func makeArchiveFile(ctx context.Context, archiveNameHint string, archiveInput [
 	// Get files from inputs as number of files decide next steps
 	files, err := utils.FindAllGlobs(archiveInput...)
 	if err != nil {
-		return "", errors.Wrap(err, "error finding all globs")
+		return "", fmt.Errorf("error finding all globs: %w", err)
 	}
 
 	// We have one file; if it's a zip file, no need to archive it
 	if len(files) == 1 {
 		// make sure it exists
 		if _, err := os.Stat(files[0]); err != nil {
-			return "", errors.Wrapf(err, "open input file %v", files[0])
+			return "", fmt.Errorf("open input file %v: %w", files[0], err)
 		}
 
 		// if it's an existing zip file OR we're not supposed to zip it, don't do anything
@@ -227,12 +228,12 @@ func makeArchiveFile(ctx context.Context, archiveNameHint string, archiveInput [
 	// For anything else, create a new archive
 	tmpDir, err := utils.GetTempDir()
 	if err != nil {
-		return "", errors.Wrap(err, "error create temporary archive directory")
+		return "", fmt.Errorf("error create temporary archive directory: %w", err)
 	}
 
 	archivePath, err := utils.MakeZipArchiveWithGlobs(ctx, filepath.Join(tmpDir, archiveFileName), archiveInput...)
 	if err != nil {
-		return "", errors.Wrap(err, "create archive file")
+		return "", fmt.Errorf("create archive file: %w", err)
 	}
 
 	return archivePath, nil

pkg/fission-cli/cmd/package/rebuild.go

@@ -19,7 +19,6 @@ package _package
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -58,17 +57,17 @@ func (opts *RebuildSubCommand) complete(input cli.Input) (err error) {
 func (opts *RebuildSubCommand) run(input cli.Input) error {
 	pkg, err := opts.Client().FissionClientSet.CoreV1().Packages(opts.namespace).Get(input.Context(), opts.name, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrapf(err, "package %s not found", opts.name)
+		return fmt.Errorf("package %s not found: %w", opts.name, err)
 	}
 
 	if pkg.Status.BuildStatus != fv1.BuildStatusFailed {
-		return errors.New(fmt.Sprintf("Package %v is not in %v state.",
+		return fmt.Errorf("Package %v is not in %v state.",
-			pkg.ObjectMeta.Name, fv1.BuildStatusFailed))
+			pkg.ObjectMeta.Name, fv1.BuildStatusFailed)
 	}
 
 	_, err = updatePackageStatus(input.Context(), opts.Client(), pkg, fv1.BuildStatusPending)
 	if err != nil {
-		return errors.Wrap(err, "update package status")
+		return fmt.Errorf("update package status: %w", err)
 	}
 
 	fmt.Printf("Retrying build for pkg %v. Use \"fission pkg info --name %v\" to view status.\n", pkg.ObjectMeta.Name, pkg.ObjectMeta.Name)

pkg/fission-cli/cmd/package/update.go

@@ -21,8 +21,9 @@ import (
 	"fmt"
 	"time"
 
+	"errors"
+
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -66,29 +67,29 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 	pkgName := input.String(flagkey.PkgName)
 	pkg, err := opts.Client().FissionClientSet.CoreV1().Packages(opts.pkgNamespace).Get(input.Context(), opts.pkgName, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting package")
+		return fmt.Errorf("error getting package: %w", err)
 	}
 
 	forceUpdate := input.Bool(flagkey.PkgForce)
 
 	fnList, err := GetFunctionsByPackage(input.Context(), opts.Client(), pkg.ObjectMeta.Name, pkg.ObjectMeta.Namespace)
 	if err != nil {
-		return errors.Wrap(err, "error getting function list")
+		return fmt.Errorf("error getting function list: %w", err)
 	}
 
 	if !forceUpdate && len(fnList) > 1 {
-		return errors.Errorf("package is used by multiple functions, use --%v to force update", flagkey.PkgForce)
+		return fmt.Errorf("package is used by multiple functions, use --%v to force update", flagkey.PkgForce)
 	}
 	specFile := fmt.Sprintf("package-%s.yaml", pkgName)
 	newPkgMeta, err := UpdatePackage(input, opts.Client(), specFile, pkg)
 	if err != nil {
-		return errors.Wrap(err, "error updating package")
+		return fmt.Errorf("error updating package: %w", err)
 	}
 
 	if pkg.ObjectMeta.ResourceVersion != newPkgMeta.ResourceVersion {
 		err = UpdateFunctionPackageResourceVersion(input.Context(), opts.Client(), newPkgMeta, fnList...)
 		if err != nil {
-			return errors.Wrap(err, "error updating function package reference resource version")
+			return fmt.Errorf("error updating function package reference resource version: %w", err)
 		}
 	}
 
@@ -130,7 +131,7 @@ func UpdatePackage(input cli.Input, client cmd.Client, specFile string, pkg *fv1
 	if input.IsSet(flagkey.PkgSrcArchive) {
 		srcArchive, err := CreateArchive(client, input, srcArchiveFiles, noZip, insecure, srcChecksum, "", "")
 		if err != nil {
-			return nil, errors.Wrap(err, "error creating source archive")
+			return nil, fmt.Errorf("error creating source archive: %w", err)
 		}
 		pkg.Spec.Source = *srcArchive
 		needToRebuild = true
@@ -146,7 +147,7 @@ func UpdatePackage(input cli.Input, client cmd.Client, specFile string, pkg *fv1
 	if input.IsSet(flagkey.PkgDeployArchive) || input.IsSet(flagkey.PkgCode) {
 		deployArchive, err := CreateArchive(client, input, deployArchiveFiles, noZip, insecure, deployChecksum, "", "")
 		if err != nil {
-			return nil, errors.Wrap(err, "error creating deploy archive")
+			return nil, fmt.Errorf("error creating deploy archive: %w", err)
 		}
 		pkg.Spec.Deployment = *deployArchive
 		// Users may update the env, envNS and deploy archive at the same time,
@@ -178,7 +179,7 @@ func UpdatePackage(input cli.Input, client cmd.Client, specFile string, pkg *fv1
 		// if a package with the same spec exists, don't create a new spec file
 		fr, err := spec.ReadSpecs(util.GetSpecDir(input), util.GetSpecIgnore(input), false)
 		if err != nil {
-			return nil, errors.Wrap(err, "error reading specs")
+			return nil, fmt.Errorf("error reading specs: %w", err)
 		}
 
 		obj := fr.SpecExists(pkg, true, true)
@@ -190,14 +191,14 @@ func UpdatePackage(input cli.Input, client cmd.Client, specFile string, pkg *fv1
 
 		err = spec.SpecSave(*pkg, specFile, true)
 		if err != nil {
-			return nil, errors.Wrap(err, "error saving package spec")
+			return nil, fmt.Errorf("error saving package spec: %w", err)
 		}
 		return &pkg.ObjectMeta, nil
 	}
 
 	newPkgMeta, err := client.FissionClientSet.CoreV1().Packages(pkg.ObjectMeta.Namespace).Update(input.Context(), pkg, metav1.UpdateOptions{})
 	if err != nil {
-		return nil, errors.Wrap(err, "update package")
+		return nil, fmt.Errorf("update package: %w", err)
 	}
 
 	fmt.Printf("Package '%v' updated\n", newPkgMeta.GetName())
@@ -213,7 +214,7 @@ func UpdateFunctionPackageResourceVersion(ctx context.Context, client cmd.Client
 		fn.Spec.Package.PackageRef.ResourceVersion = pkgMeta.ResourceVersion
 		_, err := client.FissionClientSet.CoreV1().Functions(fn.ObjectMeta.Namespace).Update(ctx, &fn, metav1.UpdateOptions{})
 		if err != nil {
-			errs = multierror.Append(errs, errors.Wrapf(err, "error updating package resource version of function '%v'", fn.ObjectMeta.Name))
+			errs = multierror.Append(errs, fmt.Errorf("error updating package resource version of function '%v': %w", fn.ObjectMeta.Name, err))
 		}
 	}
 

pkg/fission-cli/cmd/package/util/util.go

@@ -26,8 +26,6 @@ import (
 	"strings"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
-
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 	"github.com/fission/fission/pkg/fission-cli/cmd"
 	"github.com/fission/fission/pkg/fission-cli/util"
@@ -53,19 +51,19 @@ func UploadArchiveFile(ctx context.Context, client cmd.Client, fileName string)
 	} else {
 		storagesvcURL, err := util.GetStorageURL(ctx, client)
 		if err != nil {
-			return nil, errors.Wrapf(err, "error getting fission storage service URL")
+			return nil, fmt.Errorf("error getting fission storage service URL: %w", err)
 		}
 
 		storageClient := storageSvcClient.MakeClient(storagesvcURL.String())
 		// TODO add a progress bar
 		id, err := storageClient.Upload(ctx, fileName, nil)
 		if err != nil {
-			return nil, errors.Wrapf(err, "error uploading to fission storage service")
+			return nil, fmt.Errorf("error uploading to fission storage service: %w", err)
 		}
 
 		archiveURL, err := getArchiveURL(ctx, client, id, storagesvcURL)
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not get URL of archive")
+			return nil, fmt.Errorf("could not get URL of archive: %w", err)
 		}
 
 		archive.Type = fv1.ArchiveTypeUrl
@@ -73,7 +71,7 @@ func UploadArchiveFile(ctx context.Context, client cmd.Client, fileName string)
 
 		csum, err := utils.GetFileChecksum(fileName)
 		if err != nil {
-			return nil, errors.Wrapf(err, "calculate checksum for file %v", fileName)
+			return nil, fmt.Errorf("calculate checksum for file %v: %w", fileName, err)
 		}
 
 		archive.Checksum = *csum
@@ -121,7 +119,7 @@ func getArchiveURL(ctx context.Context, client cmd.Client, archiveID string, ser
 func GetContents(filePath string) ([]byte, error) {
 	code, err := os.ReadFile(filePath)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error reading %v", filePath)
+		return nil, fmt.Errorf("error reading %v: %w", filePath, err)
 	}
 	return code, nil
 }
@@ -131,13 +129,13 @@ func GetContents(filePath string) ([]byte, error) {
 func DownloadToTempFile(fileUrl string) (string, error) {
 	reader, err := DownloadURL(fileUrl)
 	if err != nil {
-		return "", errors.Wrapf(err, "error downloading from url: %v", fileUrl)
+		return "", fmt.Errorf("error downloading from url: %v: %w", fileUrl, err)
 	}
 	defer reader.Close()
 
 	tmpDir, err := utils.GetTempDir()
 	if err != nil {
-		return "", errors.Wrapf(err, "error creating temp directory %v", tmpDir)
+		return "", fmt.Errorf("error creating temp directory %v: %w", tmpDir, err)
 	}
 
 	tmpFilename := uuid.NewString()
@@ -145,7 +143,7 @@ func DownloadToTempFile(fileUrl string) (string, error) {
 
 	err = WriteArchiveToFile(destination, reader)
 	if err != nil {
-		return "", errors.Wrapf(err, "error writing archive to file %v", destination)
+		return "", fmt.Errorf("error writing archive to file %v: %w", destination, err)
 	}
 
 	return destination, nil

pkg/fission-cli/cmd/spec/apply.go

@@ -27,7 +27,6 @@ import (
 
 	"github.com/fsnotify/fsnotify"
 	"github.com/go-git/go-git/v5"
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8sCache "k8s.io/client-go/tools/cache"
 
@@ -145,14 +144,14 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 		var err error
 		watcher, err = fsnotify.NewWatcher()
 		if err != nil {
-			return errors.Wrap(err, "error creating file watcher")
+			return fmt.Errorf("error creating file watcher: %w", err)
 		}
 
 		// add watches
 		rootDir := filepath.Clean(specDir + "/..")
 		err = filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
 			if err != nil {
-				return errors.Wrap(err, "error scanning project files")
+				return fmt.Errorf("error scanning project files: %w", err)
 			}
 
 			if ignoreFile(path) {
@@ -161,12 +160,12 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 
 			err = watcher.Add(path)
 			if err != nil {
-				return errors.Wrap(err, fmt.Sprintf("error watching path %v", path))
+				return fmt.Errorf("error watching path %v: %w", path, err)
 			}
 			return nil
 		})
 		if err != nil {
-			return errors.Wrap(err, "error scanning files to watch")
+			return fmt.Errorf("error scanning files to watch: %w", err)
 		}
 	}
 
@@ -174,19 +173,19 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 		// read all specs
 		fr, err := ReadSpecs(specDir, specIgnore, applyCommitLabel)
 		if err != nil {
-			return errors.Wrap(err, "error reading specs")
+			return fmt.Errorf("error reading specs: %w", err)
 		}
 
 		if validateSpecs {
 			err = validateForApply(input, fr)
 			if err != nil {
-				return errors.Wrap(err, "abort applying resources")
+				return fmt.Errorf("abort applying resources: %w", err)
 			}
 		}
 
 		err = opts.insertNamespace(input, fr)
 		if err != nil {
-			return errors.Wrap(err, "error inserting namespace")
+			return fmt.Errorf("error inserting namespace: %w", err)
 		}
 
 		err = warnIfDirtyWorkTree(filepath.Clean(specDir + "/.."))
@@ -197,7 +196,7 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 		// make changes to the cluster based on the specs
 		pkgMetas, as, err := applyResources(input, opts.Client(), specDir, fr, deleteResources, input.Bool(flagkey.SpecAllowConflicts))
 		if err != nil {
-			return errors.Wrap(err, "error applying specs")
+			return fmt.Errorf("error applying specs: %w", err)
 		}
 		printApplyStatus(as)
 
@@ -239,7 +238,7 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 
 				err = waitForFileWatcherToSettleDown(watcher)
 				if err != nil {
-					return errors.Wrap(err, "error watching files")
+					return fmt.Errorf("error watching files: %w", err)
 				}
 				break waitloop
 
@@ -247,7 +246,7 @@ func (opts *ApplySubCommand) run(input cli.Input) error {
 				pkgWatchCancel()
 
 				if err != nil {
-					return errors.Wrap(err, "error watching files")
+					return fmt.Errorf("error watching files: %w", err)
 				}
 			}
 		}
@@ -408,7 +407,7 @@ func applyArchives(input cli.Input, fclient cmd.Client, specDir string, fr *Fiss
 			if strings.HasPrefix(ar.URL, ARCHIVE_URL_PREFIX) {
 				availableAr, ok := archiveFiles[ar.URL]
 				if !ok {
-					return errors.Errorf("unknown archive name %v", strings.TrimPrefix(ar.URL, ARCHIVE_URL_PREFIX))
+					return fmt.Errorf("unknown archive name %v", strings.TrimPrefix(ar.URL, ARCHIVE_URL_PREFIX))
 				}
 				ar.Type = availableAr.Type
 				ar.Literal = availableAr.Literal
@@ -433,13 +432,13 @@ func applyResources(input cli.Input, fclient cmd.Client, specDir string, fr *Fis
 
 	_, ras, err := applyEnvironments(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "environment apply failed")
+		return nil, nil, fmt.Errorf("environment apply failed: %w", err)
 	}
 	applyStatus["environment"] = *ras
 
 	pkgMeta, ras, err := applyPackages(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "package apply failed")
+		return nil, nil, fmt.Errorf("package apply failed: %w", err)
 	}
 	applyStatus["package"] = *ras
 
@@ -460,7 +459,7 @@ func applyResources(input cli.Input, fclient cmd.Client, specDir string, fr *Fis
 			// spec. It may exist outside the spec, but we're going to treat
 			// that as an error, so that we encourage self-contained specs.
 			// Is there a good use case for non-self contained specs?
-			return nil, nil, errors.Errorf("function %v/%v references package %v/%v, which doesn't exist in the specs",
+			return nil, nil, fmt.Errorf("function %v/%v references package %v/%v, which doesn't exist in the specs",
 				f.ObjectMeta.Namespace, f.ObjectMeta.Name, f.Spec.Package.PackageRef.Namespace, f.Spec.Package.PackageRef.Name)
 		}
 		fr.Functions[i].Spec.Package.PackageRef.ResourceVersion = m.ResourceVersion
@@ -468,31 +467,31 @@ func applyResources(input cli.Input, fclient cmd.Client, specDir string, fr *Fis
 
 	_, ras, err = applyFunctions(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "function apply failed")
+		return nil, nil, fmt.Errorf("function apply failed: %w", err)
 	}
 	applyStatus["function"] = *ras
 
 	_, ras, err = applyHTTPTriggers(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "HTTPTrigger apply failed")
+		return nil, nil, fmt.Errorf("HTTPTrigger apply failed: %w", err)
 	}
 	applyStatus["HTTPTrigger"] = *ras
 
 	_, ras, err = applyKubernetesWatchTriggers(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "KubernetesWatchTrigger apply failed")
+		return nil, nil, fmt.Errorf("KubernetesWatchTrigger apply failed: %w", err)
 	}
 	applyStatus["KubernetesWatchTrigger"] = *ras
 
 	_, ras, err = applyTimeTriggers(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "TimeTrigger apply failed")
+		return nil, nil, fmt.Errorf("TimeTrigger apply failed: %w", err)
 	}
 	applyStatus["TimeTrigger"] = *ras
 
 	_, ras, err = applyMessageQueueTriggers(input.Context(), fclient, fr, delete, specAllowConflicts)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "MessageQueueTrigger apply failed")
+		return nil, nil, fmt.Errorf("MessageQueueTrigger apply failed: %w", err)
 	}
 	applyStatus["MessageQueueTrigger"] = *ras
 
@@ -526,14 +525,14 @@ func localArchiveFromSpec(ctx context.Context, specDir string, aus *spectypes.Ar
 			console.Verbose(2, "try to find globs in path '%v'", absGlob)
 			fs, err := utils.FindAllGlobs(absGlob)
 			if err != nil {
-				return nil, errors.Wrapf(err, "Invalid glob in archive %v: %v", aus.Name, relativeGlob)
+				return nil, fmt.Errorf("Invalid glob in archive %v: %v: %w", aus.Name, relativeGlob, err)
 			}
 			files = append(files, fs...)
 		}
 	}
 
 	if len(files) == 0 {
-		return nil, errors.Errorf("archive '%v' is empty", aus.Name)
+		return nil, fmt.Errorf("archive '%v' is empty", aus.Name)
 	}
 
 	// if it's just one file, use its path directly
@@ -585,7 +584,7 @@ func localArchiveFromSpec(ctx context.Context, specDir string, aus *spectypes.Ar
 		// checksum
 		csum, err := utils.GetFileChecksum(archiveFileName)
 		if err != nil {
-			return nil, errors.Errorf("failed to calculate archive checksum for %v (%v): %v", aus.Name, archiveFileName, err)
+			return nil, fmt.Errorf("failed to calculate archive checksum for %v (%v): %v", aus.Name, archiveFileName, err)
 		}
 
 		// archive object
@@ -626,7 +625,7 @@ func waitForPackageBuild(ctx context.Context, fclient cmd.Client, pkg *fv1.Packa
 			return pkg, nil
 		}
 		if time.Since(start) > 5*time.Minute {
-			return nil, errors.Errorf("package %v has been building for a while, giving up on waiting for it", pkg.ObjectMeta.Name)
+			return nil, fmt.Errorf("package %v has been building for a while, giving up on waiting for it", pkg.ObjectMeta.Name)
 		}
 
 		// TODO watch instead

pkg/fission-cli/cmd/spec/destroy.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8sCache "k8s.io/client-go/tools/cache"
 
@@ -55,13 +54,13 @@ func (opts *DestroySubCommand) run(input cli.Input) error {
 	// read everything
 	fr, err := ReadSpecs(specDir, specIgnore, false)
 	if err != nil {
-		return errors.Wrap(err, "error reading specs")
+		return fmt.Errorf("error reading specs: %w", err)
 	}
 
 	if !input.Bool(flagkey.ForceDelete) {
 		err = opts.insertNSToResource(input, fr)
 		if err != nil {
-			return errors.Wrap(err, "error adding namespace")
+			return fmt.Errorf("error adding namespace: %w", err)
 		}
 	} else {
 		// if force delete set to true we fetch all resources with our deployment ID and delete them
@@ -72,14 +71,14 @@ func (opts *DestroySubCommand) run(input cli.Input) error {
 		// "apply" the empty state
 		err = forceDeleteResources(input.Context(), opts.Client(), &emptyFr)
 		if err != nil {
-			return errors.Wrap(err, "error deleting resources")
+			return fmt.Errorf("error deleting resources: %w", err)
 		}
 		return nil
 	}
 	forceDelete := input.Bool(flagkey.ForceDelete)
 	err = deleteResources(input.Context(), opts.Client(), fr, forceDelete)
 	if err != nil {
-		return errors.Wrap(err, "error deleting resources")
+		return fmt.Errorf("error deleting resources: %w", err)
 	}
 
 	return nil
@@ -91,37 +90,37 @@ func forceDeleteResources(ctx context.Context, fclient cmd.Client, fr *FissionRe
 
 	_, _, err = applyHTTPTriggers(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "HTTPTrigger delete failed")
+		return fmt.Errorf("HTTPTrigger delete failed: %w", err)
 	}
 
 	_, _, err = applyKubernetesWatchTriggers(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "KubernetesWatchTrigger delete failed")
+		return fmt.Errorf("KubernetesWatchTrigger delete failed: %w", err)
 	}
 
 	_, _, err = applyTimeTriggers(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "TimeTrigger delete failed")
+		return fmt.Errorf("TimeTrigger delete failed: %w", err)
 	}
 
 	_, _, err = applyMessageQueueTriggers(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "MessageQueueTrigger delete failed")
+		return fmt.Errorf("MessageQueueTrigger delete failed: %w", err)
 	}
 
 	_, _, err = applyFunctions(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "function delete failed")
+		return fmt.Errorf("function delete failed: %w", err)
 	}
 
 	_, _, err = applyPackages(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "package delete failed")
+		return fmt.Errorf("package delete failed: %w", err)
 	}
 
 	_, _, err = applyEnvironments(ctx, fclient, fr, true, false)
 	if err != nil {
-		return errors.Wrap(err, "environment delete failed")
+		return fmt.Errorf("environment delete failed: %w", err)
 	}
 
 	return nil
@@ -183,37 +182,37 @@ func deleteResources(ctx context.Context, fclient cmd.Client, fr *FissionResourc
 
 	err = destroyHTTPTriggers(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "HTTPTrigger delete failed")
+		return fmt.Errorf("HTTPTrigger delete failed: %w", err)
 	}
 
 	err = destroyKubernetesWatchTriggers(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "KubernetesWatchTrigger delete failed")
+		return fmt.Errorf("KubernetesWatchTrigger delete failed: %w", err)
 	}
 
 	err = destroyTimeTriggers(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "TimeTrigger delete failed")
+		return fmt.Errorf("TimeTrigger delete failed: %w", err)
 	}
 
 	err = destroyMessageQueueTriggers(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "MessageQueueTrigger delete failed")
+		return fmt.Errorf("MessageQueueTrigger delete failed: %w", err)
 	}
 
 	err = destroyFunctions(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "function delete failed")
+		return fmt.Errorf("function delete failed: %w", err)
 	}
 
 	err = destroyPackages(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "package delete failed")
+		return fmt.Errorf("package delete failed: %w", err)
 	}
 
 	err = destroyEnvironments(ctx, fclient, fr)
 	if err != nil {
-		return errors.Wrap(err, "environment delete failed")
+		return fmt.Errorf("environment delete failed: %w", err)
 	}
 
 	return nil

pkg/fission-cli/cmd/spec/init.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/pkg/errors"
 	"sigs.k8s.io/yaml"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -58,7 +57,7 @@ func (opts *InitSubCommand) complete(input cli.Input) error {
 		// come up with a name using the current dir
 		dir, err := filepath.Abs(".")
 		if err != nil {
-			return errors.Wrap(err, "error getting current working directory")
+			return fmt.Errorf("error getting current working directory: %w", err)
 		}
 		basename := filepath.Base(dir)
 		name = util.KubifyName(basename)
@@ -73,7 +72,7 @@ func (opts *InitSubCommand) complete(input cli.Input) error {
 	fmt.Printf("Creating fission spec directory '%v'\n", specDir)
 	err := os.MkdirAll(specDir, 0755)
 	if err != nil {
-		return errors.Wrapf(err, "create spec directory '%v'", specDir)
+		return fmt.Errorf("create spec directory '%v': %w", specDir, err)
 	}
 
 	// Write the deployment config
@@ -101,7 +100,7 @@ func (opts *InitSubCommand) run(input cli.Input) error {
 	config := filepath.Join(specDir, "fission-deployment-config.yaml")
 
 	if _, err := os.Stat(config); err == nil {
-		return errors.Errorf("Spec DeploymentConfig already exists in directory '%v'", specDir)
+		return fmt.Errorf("Spec DeploymentConfig already exists in directory '%v'", specDir)
 	}
 
 	// Add a bit of documentation to the spec dir here
@@ -112,7 +111,7 @@ func (opts *InitSubCommand) run(input cli.Input) error {
 
 	err = writeDeploymentConfig(config, opts.deployConfig)
 	if err != nil {
-		return errors.Wrap(err, "error writing deployment config")
+		return fmt.Errorf("error writing deployment config: %w", err)
 	}
 
 	// Other possible things to do here:

pkg/fission-cli/cmd/spec/list.go

@@ -24,7 +24,6 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -56,7 +55,7 @@ func (opts *ListSubCommand) run(input cli.Input) error {
 		specIgnore := util.GetSpecIgnore(input)
 		fr, err := ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, "error reading specs")
+			return fmt.Errorf("error reading specs: %w", err)
 		}
 		deployID = fr.DeploymentConfig.UID
 	}
@@ -83,7 +82,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 
 	allfn, err = getAllFunctions(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting Functions from %s namespaces", printNS))
+		return fmt.Errorf("error getting Functions from %s namespaces: %w", printNS, err)
 	}
 	specfns := getAppliedFunctions(allfn, deployID)
 	ShowFunctions(specfns)
@@ -91,7 +90,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var allenvs []fv1.Environment
 	allenvs, err = getAllEnvironments(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting Environments from  %s namespaces", printNS))
+		return fmt.Errorf("error getting Environments from  %s namespaces: %w", printNS, err)
 	}
 	specenvs := getAppliedEnvironments(allenvs, deployID)
 	ShowEnvironments(specenvs)
@@ -99,7 +98,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var pkglists []fv1.Package
 	pkglists, err = getAllPackages(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting Packages from  %s namespaces", printNS))
+		return fmt.Errorf("error getting Packages from  %s namespaces: %w", printNS, err)
 	}
 	specPkgs := getAppliedPackages(pkglists, deployID)
 	ShowPackages(specPkgs)
@@ -107,7 +106,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var canaryCfgs []fv1.CanaryConfig
 	canaryCfgs, err = getAllCanaryConfigs(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting Canary Config from  %s namespaces", printNS))
+		return fmt.Errorf("error getting Canary Config from  %s namespaces: %w", printNS, err)
 	}
 	specCanaryCfgs := getAppliedCanaryConfigs(canaryCfgs, deployID)
 	ShowCanaryConfigs(specCanaryCfgs)
@@ -115,7 +114,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var hts []fv1.HTTPTrigger
 	hts, err = getAllHTTPTriggers(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting HTTP Triggers from  %s namespaces", printNS))
+		return fmt.Errorf("error getting HTTP Triggers from  %s namespaces: %w", printNS, err)
 	}
 	specHTTPTriggers := getAppliedHTTPTriggers(hts, deployID)
 	ShowHTTPTriggers(specHTTPTriggers)
@@ -123,7 +122,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var mqts []fv1.MessageQueueTrigger
 	mqts, err = getAllMessageQueueTriggers(input.Context(), opts.Client(), input.String(flagkey.MqtMQType), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting MessageQueue Triggers from  %s namespaces", printNS))
+		return fmt.Errorf("error getting MessageQueue Triggers from  %s namespaces: %w", printNS, err)
 	}
 	specMessageQueueTriggers := getAppliedMessageQueueTriggers(mqts, deployID)
 	ShowMQTriggers(specMessageQueueTriggers)
@@ -131,7 +130,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var tts []fv1.TimeTrigger
 	tts, err = getAllTimeTriggers(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting Time Triggers from  %s namespaces", printNS))
+		return fmt.Errorf("error getting Time Triggers from  %s namespaces: %w", printNS, err)
 	}
 	specTimeTriggers := getAppliedTimeTriggers(tts, deployID)
 	ShowTimeTriggers(specTimeTriggers)
@@ -139,7 +138,7 @@ func (opts *ListSubCommand) getResource(input cli.Input, namespace string, deplo
 	var kws []fv1.KubernetesWatchTrigger
 	kws, err = getAllKubeWatchTriggers(input.Context(), opts.Client(), namespace)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error getting Kube Watchers from  %s namespaces", printNS))
+		return fmt.Errorf("error getting Kube Watchers from  %s namespaces: %w", printNS, err)
 	}
 	specKubeWatchers := getSpecKubeWatchers(kws, deployID)
 	ShowAppliedKubeWatchers(specKubeWatchers)
@@ -424,7 +423,7 @@ func ShowAppliedKubeWatchers(ws []fv1.KubernetesWatchTrigger) {
 func getAllFunctions(ctx context.Context, client cmd.Client, namespace string) ([]fv1.Function, error) {
 	fns, err := client.FissionClientSet.CoreV1().Functions(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get Functions %v", err.Error())
+		return nil, fmt.Errorf("Unable to get Functions %v", err.Error())
 	}
 	return fns.Items, nil
 }
@@ -433,7 +432,7 @@ func getAllFunctions(ctx context.Context, client cmd.Client, namespace string) (
 func getAllEnvironments(ctx context.Context, client cmd.Client, namespace string) ([]fv1.Environment, error) {
 	envs, err := client.FissionClientSet.CoreV1().Environments(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get Environments %v", err.Error())
+		return nil, fmt.Errorf("Unable to get Environments %v", err.Error())
 	}
 	return envs.Items, nil
 }
@@ -442,7 +441,7 @@ func getAllEnvironments(ctx context.Context, client cmd.Client, namespace string
 func getAllPackages(ctx context.Context, client cmd.Client, namespace string) ([]fv1.Package, error) {
 	pkgList, err := client.FissionClientSet.CoreV1().Packages(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get Packages %v", err.Error())
+		return nil, fmt.Errorf("Unable to get Packages %v", err.Error())
 	}
 	return pkgList.Items, nil
 }
@@ -451,7 +450,7 @@ func getAllPackages(ctx context.Context, client cmd.Client, namespace string) ([
 func getAllCanaryConfigs(ctx context.Context, client cmd.Client, namespace string) ([]fv1.CanaryConfig, error) {
 	canaryCfgs, err := client.FissionClientSet.CoreV1().CanaryConfigs(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get Canary Configs %v", err.Error())
+		return nil, fmt.Errorf("Unable to get Canary Configs %v", err.Error())
 	}
 	return canaryCfgs.Items, nil
 }
@@ -460,7 +459,7 @@ func getAllCanaryConfigs(ctx context.Context, client cmd.Client, namespace strin
 func getAllHTTPTriggers(ctx context.Context, client cmd.Client, namespace string) ([]fv1.HTTPTrigger, error) {
 	hts, err := client.FissionClientSet.CoreV1().HTTPTriggers(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get HTTP Triggers %v", err.Error())
+		return nil, fmt.Errorf("Unable to get HTTP Triggers %v", err.Error())
 	}
 	return hts.Items, nil
 }
@@ -469,7 +468,7 @@ func getAllHTTPTriggers(ctx context.Context, client cmd.Client, namespace string
 func getAllMessageQueueTriggers(ctx context.Context, client cmd.Client, mqttype string, namespace string) ([]fv1.MessageQueueTrigger, error) {
 	mqts, err := client.FissionClientSet.CoreV1().MessageQueueTriggers(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get MessageQueue Triggers %v", err.Error())
+		return nil, fmt.Errorf("Unable to get MessageQueue Triggers %v", err.Error())
 	}
 	return mqts.Items, nil
 }
@@ -478,7 +477,7 @@ func getAllMessageQueueTriggers(ctx context.Context, client cmd.Client, mqttype
 func getAllTimeTriggers(ctx context.Context, client cmd.Client, namespace string) ([]fv1.TimeTrigger, error) {
 	tts, err := client.FissionClientSet.CoreV1().TimeTriggers(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get Time Triggers %v", err.Error())
+		return nil, fmt.Errorf("Unable to get Time Triggers %v", err.Error())
 	}
 	return tts.Items, nil
 }
@@ -487,7 +486,7 @@ func getAllTimeTriggers(ctx context.Context, client cmd.Client, namespace string
 func getAllKubeWatchTriggers(ctx context.Context, client cmd.Client, namespace string) ([]fv1.KubernetesWatchTrigger, error) {
 	ws, err := client.FissionClientSet.CoreV1().KubernetesWatchTriggers(namespace).List(ctx, metav1.ListOptions{})
 	if err != nil {
-		return nil, errors.Errorf("Unable to get Kube Watchers %v", err.Error())
+		return nil, fmt.Errorf("Unable to get Kube Watchers %v", err.Error())
 	}
 	return ws.Items, nil
 }

pkg/fission-cli/cmd/spec/spec.go

@@ -24,7 +24,6 @@ import (
 	"strings"
 
 	multierror "github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8sCache "k8s.io/client-go/tools/cache"
@@ -128,7 +127,7 @@ type (
 func save(data []byte, specDir string, specFile string, truncate bool) error {
 	// verify
 	if _, err := os.Stat(filepath.Join(specDir, "fission-deployment-config.yaml")); os.IsNotExist(err) {
-		return errors.Wrap(err, "Couldn't find specs, run `fission spec init` first")
+		return fmt.Errorf("Couldn't find specs, run `fission spec init` first: %w", err)
 	}
 
 	filename := filepath.Join(specDir, specFile)
@@ -136,7 +135,7 @@ func save(data []byte, specDir string, specFile string, truncate bool) error {
 	newFile := false
 	if _, err := os.Stat(filename); os.IsNotExist(err) {
 		if truncate {
-			return errors.Errorf("spec file does not exists")
+			return fmt.Errorf("spec file does not exists")
 		}
 		newFile = true
 	}
@@ -144,14 +143,14 @@ func save(data []byte, specDir string, specFile string, truncate bool) error {
 	// open spec file to append or write
 	f, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
 	if err != nil {
-		return errors.Wrap(err, "couldn't create spec file")
+		return fmt.Errorf("couldn't create spec file: %w", err)
 	}
 	defer f.Close()
 
 	if truncate {
 		err = f.Truncate(0)
 		if err != nil {
-			return errors.Wrap(err, "couldn't truncate the spec file")
+			return fmt.Errorf("couldn't truncate the spec file: %w", err)
 		}
 
 	} else {
@@ -159,7 +158,7 @@ func save(data []byte, specDir string, specFile string, truncate bool) error {
 		if !newFile {
 			_, err = f.Write([]byte("\n---\n"))
 			if err != nil {
-				return errors.Wrap(err, "couldn't write to spec file")
+				return fmt.Errorf("couldn't write to spec file: %w", err)
 			}
 		}
 	}
@@ -167,7 +166,7 @@ func save(data []byte, specDir string, specFile string, truncate bool) error {
 	// write our resource
 	_, err = f.Write(data)
 	if err != nil {
-		return errors.Wrap(err, "couldn't write to spec file")
+		return fmt.Errorf("couldn't write to spec file: %w", err)
 	}
 	return nil
 }
@@ -183,7 +182,7 @@ func SpecSave(resource interface{}, specFile string, update bool) error {
 
 	fr, err := ReadSpecs(specDir, util.SPEC_IGNORE_FILE, false)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("error reading spec in '%v'", specDir))
+		return fmt.Errorf("error reading spec in '%v': %w", specDir, err)
 	}
 
 	exists, err := fr.ExistsInSpecs(resource)
@@ -192,7 +191,7 @@ func SpecSave(resource interface{}, specFile string, update bool) error {
 	}
 
 	if exists {
-		return errors.Errorf("same name resource (%v) already exists in namespace (%v)", meta.Name, meta.Namespace)
+		return fmt.Errorf("same name resource (%v) already exists in namespace (%v)", meta.Name, meta.Namespace)
 	}
 
 	truncate := false
@@ -277,11 +276,11 @@ func crdToYaml(resource interface{}) (metav1.ObjectMeta, string, []byte, error)
 		kind = typedres.TypeMeta.Kind
 		data, err = yaml.Marshal(typedres)
 	default:
-		err = errors.Errorf("unknown object type '%v'", typedres)
+		err = fmt.Errorf("unknown object type '%v'", typedres)
 	}
 
 	if err != nil {
-		return metav1.ObjectMeta{}, "", nil, errors.Wrap(err, "couldn't marshal YAML")
+		return metav1.ObjectMeta{}, "", nil, fmt.Errorf("couldn't marshal YAML: %w", err)
 	}
 
 	return meta, kind, data, nil
@@ -559,7 +558,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 	var tm types.TypeMeta
 	err := yaml.Unmarshal(b, &tm)
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("Failed to decode yaml %v", string(b)))
+		return fmt.Errorf("Failed to decode yaml %s: %w", string(b), err)
 	}
 
 	switch tm.Kind {
@@ -567,7 +566,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.Package
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -576,7 +575,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.Function
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -585,7 +584,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.Environment
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -594,7 +593,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.HTTPTrigger
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -603,7 +602,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.KubernetesWatchTrigger
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -612,7 +611,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.TimeTrigger
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -621,7 +620,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v fv1.MessageQueueTrigger
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 		m = &v.ObjectMeta
 		applyCommitLabel(commitLabelVal, m)
@@ -633,7 +632,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v types.DeploymentConfig
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 
 		fr.DeploymentConfig = v
@@ -641,7 +640,7 @@ func (fr *FissionResources) ParseYaml(b []byte, loc *Location, commitLabelVal st
 		var v types.ArchiveUploadSpec
 		err = yaml.Unmarshal(b, &v)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("Failed to parse %v in %v", tm.Kind, loc))
+			return fmt.Errorf("Failed to parse %v in %v: %w", tm.Kind, loc, err)
 		}
 
 		m = &metav1.ObjectMeta{

pkg/fission-cli/cmd/spec/validate.go

@@ -25,7 +25,6 @@ import (
 	"strings"
 
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 
@@ -71,7 +70,7 @@ func (opts *ValidateSubCommand) run(input cli.Input, fr *FissionResources) (err
 	if fr == nil {
 		fr, err = ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, "error reading specs")
+			return fmt.Errorf("error reading specs: %w", err)
 		}
 	}
 
@@ -83,12 +82,12 @@ func (opts *ValidateSubCommand) run(input cli.Input, fr *FissionResources) (err
 	// this does the rest of the checks, like dangling refs
 	warnings, err = fr.Validate(input, opts.Client())
 	if err != nil {
-		return errors.Wrap(err, "error validating specs")
+		return fmt.Errorf("error validating specs: %w", err)
 	}
 
 	err = resourceConflictCheck(input.Context(), opts.Client(), fr, input.Bool(flagkey.SpecAllowConflicts), "")
 	if err != nil {
-		return errors.Wrap(err, "name conflict error")
+		return fmt.Errorf("name conflict error: %w", err)
 	}
 
 	for _, warning := range warnings {
@@ -110,7 +109,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	fnList, err := getAllFunctions(ctx, c, namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get Functions %v", err.Error())
+		return fmt.Errorf("Unable to get Functions %v", err.Error())
 	}
 	for _, sObj := range fr.Functions {
 		for _, cObj := range fnList {
@@ -123,7 +122,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	envList, err := getAllEnvironments(ctx, c, namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get Environments %v", err.Error())
+		return fmt.Errorf("Unable to get Environments %v", err.Error())
 	}
 	for _, sObj := range fr.Environments {
 		for _, cObj := range envList {
@@ -136,7 +135,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	pkgList, err := getAllPackages(ctx, c, namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get Packages %v", err.Error())
+		return fmt.Errorf("Unable to get Packages %v", err.Error())
 	}
 	for _, sObj := range fr.Packages {
 		for _, cObj := range pkgList {
@@ -149,7 +148,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	httptriggerList, err := getAllHTTPTriggers(ctx, c, namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get HTTPTrigger %v", err.Error())
+		return fmt.Errorf("Unable to get HTTPTrigger %v", err.Error())
 	}
 	for _, sObj := range fr.HttpTriggers {
 		for _, cObj := range httptriggerList {
@@ -162,7 +161,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	mqtriggerList, err := getAllMessageQueueTriggers(ctx, c, "", namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get Message Queue Trigger %v", err.Error())
+		return fmt.Errorf("Unable to get Message Queue Trigger %v", err.Error())
 	}
 	for _, sObj := range fr.MessageQueueTriggers {
 		for _, cObj := range mqtriggerList {
@@ -175,7 +174,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	timetriggerList, err := getAllTimeTriggers(ctx, c, namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get Time Trigger %v", err.Error())
+		return fmt.Errorf("Unable to get Time Trigger %v", err.Error())
 	}
 	for _, sObj := range fr.TimeTriggers {
 		for _, cObj := range timetriggerList {
@@ -188,7 +187,7 @@ func resourceConflictCheck(ctx context.Context, c cmd.Client, fr *FissionResourc
 
 	kubewatchtriggerList, err := getAllKubeWatchTriggers(ctx, c, namespace)
 	if err != nil {
-		return errors.Errorf("Unable to get Kubernetes Watch Trigger %v", err.Error())
+		return fmt.Errorf("Unable to get Kubernetes Watch Trigger %v", err.Error())
 	}
 	for _, sObj := range fr.KubernetesWatchTriggers {
 		for _, cObj := range kubewatchtriggerList {
@@ -226,7 +225,7 @@ func ReadSpecs(specDir, specIgnore string, applyCommitLabel bool) (*FissionResou
 
 	// make sure spec directory exists before continue
 	if _, err := os.Stat(specDir); os.IsNotExist(err) {
-		return nil, errors.Errorf("Spec directory %v doesn't exist. "+
+		return nil, fmt.Errorf("Spec directory %v doesn't exist. "+
 			"Please check directory path or run \"fission spec init\" to create it.", specDir)
 	}
 

pkg/fission-cli/cmd/support/dump.go

@@ -23,8 +23,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
 	"github.com/fission/fission/pkg/fission-cli/cmd"
 	"github.com/fission/fission/pkg/fission-cli/cmd/support/resources"
@@ -58,12 +56,12 @@ func (opts *DumpSubCommand) do(input cli.Input) error {
 			panic(err)
 		}
 	} else if err != nil {
-		panic(errors.Wrap(err, "Error checking dump directory status"))
+		panic(fmt.Errorf("Error checking dump directory status: %w", err))
 	}
 
 	outputDir, err = filepath.Abs(outputDir)
 	if err != nil {
-		panic(errors.Wrap(err, "Error creating dump directory for dumping files"))
+		panic(fmt.Errorf("Error creating dump directory for dumping files: %w", err))
 	}
 
 	k8sClient := opts.Client().KubernetesClient

pkg/fission-cli/cmd/timetrigger/create.go

@@ -23,7 +23,8 @@ import (
 	"github.com/fission/fission/pkg/fission-cli/cmd"
 	"github.com/fission/fission/pkg/utils/uuid"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	"github.com/robfig/cron/v3"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -65,7 +66,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) (err error) {
 
 	userProvidedNS, fnNamespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceFunction)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	cronSpec := input.String(flagkey.TtCron)
@@ -78,7 +79,7 @@ func (opts *CreateSubCommand) complete(input cli.Input) (err error) {
 		specIgnore := util.GetSpecIgnore(input)
 		fr, err := spec.ReadSpecs(specDir, specIgnore, false)
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("error reading spec in '%v'", specDir))
+			return fmt.Errorf("error reading spec in '%v': %w", specDir, err)
 		}
 
 		exists, err := fr.ExistsInSpecs(fv1.Function{
@@ -135,14 +136,14 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("timetrigger-%v.yaml", opts.trigger.ObjectMeta.Name)
 		err := spec.SpecSave(*opts.trigger, specFile, false)
 		if err != nil {
-			return errors.Wrap(err, "error saving time trigger spec")
+			return fmt.Errorf("error saving time trigger spec: %w", err)
 		}
 		return nil
 	}
 
 	_, err := opts.Client().FissionClientSet.CoreV1().TimeTriggers(opts.trigger.Namespace).Create(input.Context(), opts.trigger, metav1.CreateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error creating Time trigger")
+		return fmt.Errorf("error creating Time trigger: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' created\n", opts.trigger.ObjectMeta.Name)
@@ -151,7 +152,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 
 	err = getCronNextNActivationTime(opts.trigger.Spec.Cron, t, 1)
 	if err != nil {
-		return errors.Wrap(err, "error passing cron spec examination")
+		return fmt.Errorf("error passing cron spec examination: %w", err)
 	}
 
 	return nil

pkg/fission-cli/cmd/timetrigger/delete.go

@@ -19,7 +19,6 @@ package timetrigger
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -40,7 +39,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) (err error) {
 
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	err = opts.Client().FissionClientSet.CoreV1().TimeTriggers(namespace).Delete(input.Context(), input.String(flagkey.TtName), metav1.DeleteOptions{})
@@ -48,7 +47,7 @@ func (opts *DeleteSubCommand) do(input cli.Input) (err error) {
 		if input.Bool(flagkey.IgnoreNotFound) && kerrors.IsNotFound(err) {
 			return nil
 		}
-		return errors.Wrap(err, "error deleting trigger")
+		return fmt.Errorf("error deleting trigger: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' deleted\n", input.String(flagkey.TtName))

pkg/fission-cli/cmd/timetrigger/list.go

@@ -21,7 +21,6 @@ import (
 	"os"
 	"text/tabwriter"
 
-	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -40,7 +39,7 @@ func List(input cli.Input) error {
 func (opts *ListSubCommand) do(input cli.Input) (err error) {
 	_, ttNs, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	if input.Bool(flagkey.AllNamespaces) {
@@ -49,7 +48,7 @@ func (opts *ListSubCommand) do(input cli.Input) (err error) {
 	tts, err := opts.Client().FissionClientSet.CoreV1().TimeTriggers(ttNs).List(input.Context(), metav1.ListOptions{})
 
 	if err != nil {
-		return errors.Wrap(err, "list Time triggers")
+		return fmt.Errorf("list Time triggers: %w", err)
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)

pkg/fission-cli/cmd/timetrigger/test.go

@@ -17,7 +17,9 @@ limitations under the License.
 package timetrigger
 
 import (
-	"github.com/pkg/errors"
+	"fmt"
+
+	"errors"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
 	"github.com/fission/fission/pkg/fission-cli/cmd"
@@ -49,7 +51,7 @@ func (opts *ShowSubCommand) run(flaginput cli.Input) error {
 
 	err := getCronNextNActivationTime(cronSpec, t, round)
 	if err != nil {
-		return errors.Wrap(err, "error passing cron spec examination")
+		return fmt.Errorf("error passing cron spec examination: %w", err)
 	}
 
 	return nil

pkg/fission-cli/cmd/timetrigger/update.go

@@ -19,7 +19,8 @@ package timetrigger
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -51,12 +52,12 @@ func (opts *UpdateSubCommand) do(input cli.Input) error {
 func (opts *UpdateSubCommand) complete(input cli.Input) error {
 	_, namespace, err := opts.GetResourceNamespace(input, flagkey.NamespaceTrigger)
 	if err != nil {
-		return errors.Wrap(err, "error in deleting function ")
+		return fmt.Errorf("error in deleting function : %w", err)
 	}
 
 	tt, err := opts.Client().FissionClientSet.CoreV1().TimeTriggers(namespace).Get(input.Context(), input.String(flagkey.TtName), metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error getting time trigger")
+		return fmt.Errorf("error getting time trigger: %w", err)
 	}
 
 	updated := false
@@ -105,13 +106,13 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 		specFile := fmt.Sprintf("timetrigger-%s.yaml", opts.trigger.ObjectMeta.Name)
 		err = spec.SpecSave(*opts.trigger, specFile, true)
 		if err != nil {
-			return errors.Wrap(err, "error saving time trigger spec")
+			return fmt.Errorf("error saving time trigger spec: %w", err)
 		}
 		return nil
 	}
 	_, err := opts.Client().FissionClientSet.CoreV1().TimeTriggers(opts.trigger.ObjectMeta.Namespace).Update(input.Context(), opts.trigger, metav1.UpdateOptions{})
 	if err != nil {
-		return errors.Wrap(err, "error updating Time trigger")
+		return fmt.Errorf("error updating Time trigger: %w", err)
 	}
 
 	fmt.Printf("trigger '%v' updated\n", opts.trigger.ObjectMeta.Name)
@@ -123,7 +124,7 @@ func (opts *UpdateSubCommand) run(input cli.Input) error {
 
 	err = getCronNextNActivationTime(opts.trigger.Spec.Cron, t, 1)
 	if err != nil {
-		return errors.Wrap(err, "error passing cron spec examination")
+		return fmt.Errorf("error passing cron spec examination: %w", err)
 	}
 
 	return nil

pkg/fission-cli/cmd/token/create.go

@@ -24,8 +24,6 @@ import (
 	"net/http"
 	"os"
 
-	"github.com/pkg/errors"
-
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
 	"github.com/fission/fission/pkg/fission-cli/cmd"
@@ -73,7 +71,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 	}
 	routerURL, err := util.GetRouterURL(input.Context(), opts.Client())
 	if err != nil {
-		return errors.Wrap(err, "error getting router URL")
+		return fmt.Errorf("error getting router URL: %w", err)
 	}
 	authAuthenticatorUrl := routerURL.JoinPath(authURI)
 	console.Verbose(2, "Auth URI: %s", authAuthenticatorUrl.String())
@@ -86,7 +84,7 @@ func (opts *CreateSubCommand) run(input cli.Input) error {
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return errors.Wrap(err, "error creating token")
+		return fmt.Errorf("error creating token: %w", err)
 	}
 
 	if resp.StatusCode == http.StatusCreated {

pkg/fission-cli/cmd/version/version.go

@@ -19,7 +19,6 @@ package version
 import (
 	"fmt"
 
-	"github.com/pkg/errors"
 	"sigs.k8s.io/yaml"
 
 	"github.com/fission/fission/pkg/fission-cli/cliwrapper/cli"
@@ -39,7 +38,7 @@ func (opts *VersionSubCommand) do(input cli.Input) error {
 	ver := util.GetVersion(input.Context(), input, opts.Client())
 	bs, err := yaml.Marshal(ver)
 	if err != nil {
-		return errors.Wrap(err, "error formatting versions")
+		return fmt.Errorf("error formatting versions: %w", err)
 	}
 	fmt.Print(string(bs))
 	return nil

pkg/fission-cli/logdb/influxdb.go

@@ -29,7 +29,6 @@ import (
 	"time"
 
 	influxdbClient "github.com/influxdata/influxdb/client/v2"
-	"github.com/pkg/errors"
 
 	ferror "github.com/fission/fission/pkg/error"
 	"github.com/fission/fission/pkg/fission-cli/util"
@@ -153,12 +152,12 @@ func (influx InfluxDB) GetLogs(ctx context.Context, filter LogFilter, output *by
 			msg := fmt.Sprintf("Timestamp: %s\nNamespace: %s\nFunction Name: %s\nFunction ID: %s\nPod: %s\nContainer: %s\nStream: %s\nLog: %s\n---\n",
 				logEntry.Timestamp, logEntry.Namespace, logEntry.FuncName, logEntry.FuncUid, logEntry.Pod, logEntry.Container, logEntry.Stream, logEntry.Message)
 			if _, err := output.WriteString(msg); err != nil {
-				return errors.Wrapf(err, "error copying pod log")
+				return fmt.Errorf("error copying pod log: %w", err)
 			}
 		} else {
 			msg := fmt.Sprintf("[%s] %s\n", logEntry.Timestamp, logEntry.Message)
 			if _, err := output.WriteString(msg); err != nil {
-				return errors.Wrapf(err, "error copying pod log")
+				return fmt.Errorf("error copying pod log: %w", err)
 			}
 		}
 	}
@@ -173,7 +172,7 @@ func (influx InfluxDB) query(ctx context.Context, query influxdbClient.Query) (*
 
 	req, err := http.NewRequest(http.MethodPost, influx.endpoint, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating request for log proxy")
+		return nil, fmt.Errorf("error creating request for log proxy: %w", err)
 	}
 	req.SetBasicAuth(username, password)
 

pkg/fission-cli/logdb/kubernetes_log.go

@@ -24,7 +24,6 @@ import (
 	"sort"
 	"strconv"
 
-	"github.com/pkg/errors"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
@@ -85,7 +84,7 @@ func GetFunctionPodLogs(ctx context.Context, client cmd.Client, logFilter LogFil
 	}
 
 	if len(podList.Items) <= 0 {
-		return errors.Errorf("no active pods found for function in namespace %s", podNs)
+		return fmt.Errorf("no active pods found for function in namespace %s", podNs)
 	}
 
 	pods := podList.Items
@@ -94,7 +93,7 @@ func GetFunctionPodLogs(ctx context.Context, client cmd.Client, logFilter LogFil
 			// get the pod with highest resource version
 			err = streamContainerLog(ctx, client.KubernetesClient, &pod, logFilter, podLogs)
 			if err != nil {
-				return errors.Wrapf(err, "error getting container logs")
+				return fmt.Errorf("error getting container logs: %w", err)
 			}
 		}
 	} else {
@@ -108,7 +107,7 @@ func GetFunctionPodLogs(ctx context.Context, client cmd.Client, logFilter LogFil
 		// get the pod with highest resource version
 		err = streamContainerLog(ctx, client.KubernetesClient, &pods[0], logFilter, podLogs)
 		if err != nil {
-			return errors.Wrapf(err, "error getting container logs")
+			return fmt.Errorf("error getting container logs: %w", err)
 		}
 	}
 
@@ -132,7 +131,7 @@ func streamContainerLog(ctx context.Context, kubernetesClient kubernetes.Interfa
 
 		podLogs, err := podLogsReq.Stream(ctx)
 		if err != nil {
-			return errors.Wrapf(err, "error streaming pod log")
+			return fmt.Errorf("error streaming pod log: %w", err)
 		}
 
 		if logFilter.Details {
@@ -140,13 +139,13 @@ func streamContainerLog(ctx context.Context, kubernetesClient kubernetes.Interfa
 			msg := fmt.Sprintf("\n=== Function=%s Environment=%s Namespace=%s Pod=%s Container=%s Node=%s\n",
 				fn.ObjectMeta.Name, fn.Spec.Environment.Name, pod.Namespace, pod.Name, container.Name, pod.Spec.NodeName)
 			if _, err := output.WriteString(msg); err != nil {
-				return errors.Wrapf(err, "error copying pod log")
+				return fmt.Errorf("error copying pod log: %w", err)
 			}
 		}
 
 		_, err = io.Copy(output, podLogs)
 		if err != nil {
-			return errors.Wrapf(err, "error copying pod log")
+			return fmt.Errorf("error copying pod log: %w", err)
 		}
 
 		podLogs.Close()

pkg/fission-cli/util/portforward.go

@@ -26,7 +26,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/tools/portforward"
@@ -50,7 +49,7 @@ func SetupPortForward(ctx context.Context, client cmd.Client, namespace, labelSe
 
 	lcPort, err := utils.FindFreePort()
 	if err != nil {
-		return "", errors.Wrap(err, "error finding unused port")
+		return "", fmt.Errorf("error finding unused port: %w", err)
 	}
 	localPort := strconv.Itoa(lcPort)
 
@@ -118,9 +117,9 @@ func runPortForward(ctx context.Context, client cmd.Client, labelSelector string
 	podList, err := client.KubernetesClient.CoreV1().Pods(ns).
 		List(ctx, metav1.ListOptions{LabelSelector: labelSelector})
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "error getting pod for port-forwarding with label selector %v", labelSelector)
+		return nil, nil, fmt.Errorf("error getting pod for port-forwarding with label selector %v: %w", labelSelector, err)
 	} else if len(podList.Items) == 0 {
-		return nil, nil, errors.Errorf("no available pod for port-forwarding with label selector %v", labelSelector)
+		return nil, nil, fmt.Errorf("no available pod for port-forwarding with label selector %v", labelSelector)
 	}
 
 	nsList := make([]string, 0)
@@ -136,7 +135,7 @@ func runPortForward(ctx context.Context, client cmd.Client, labelSelector string
 			namespaces[p.Namespace] = append(namespaces[p.Namespace], &p)
 		}
 		if len(nsList) > 1 {
-			return nil, nil, errors.Errorf("Found %v fission installs, set FISSION_NAMESPACE to one of: %v",
+			return nil, nil, fmt.Errorf("Found %v fission installs, set FISSION_NAMESPACE to one of: %v",
 				len(namespaces), strings.Join(nsList, " "))
 		}
 	}
@@ -146,7 +145,7 @@ func runPortForward(ctx context.Context, client cmd.Client, labelSelector string
 	ns = nsList[0]
 	pods, ok := namespaces[ns]
 	if !ok {
-		return nil, nil, errors.Errorf("Error finding fission install within the given namespace %v, please check FISSION_NAMESPACE is set properly", ns)
+		return nil, nil, fmt.Errorf("Error finding fission install within the given namespace %v, please check FISSION_NAMESPACE is set properly", ns)
 	}
 
 	var podName, podNameSpace string
@@ -164,10 +163,10 @@ func runPortForward(ctx context.Context, client cmd.Client, labelSelector string
 	svcs, err := client.KubernetesClient.CoreV1().Services(podNameSpace).
 		List(ctx, metav1.ListOptions{LabelSelector: labelSelector})
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "Error getting %v service", labelSelector)
+		return nil, nil, fmt.Errorf("Error getting %v service: %w", labelSelector, err)
 	}
 	if len(svcs.Items) == 0 {
-		return nil, nil, errors.Errorf("Service %v not found", labelSelector)
+		return nil, nil, fmt.Errorf("Service %v not found", labelSelector)
 	}
 	service := &svcs.Items[0]
 
@@ -192,7 +191,7 @@ func runPortForward(ctx context.Context, client cmd.Client, labelSelector string
 	// actually start the port-forwarding process here
 	transport, upgrader, err := spdy.RoundTripperFor(client.RestConfig)
 	if err != nil {
-		return nil, nil, errors.Errorf("Failed to connect to Fission service on Kubernetes")
+		return nil, nil, fmt.Errorf("Failed to connect to Fission service on Kubernetes")
 	}
 	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", url)
 
@@ -202,7 +201,7 @@ func runPortForward(ctx context.Context, client cmd.Client, labelSelector string
 	}
 	fw, err := portforward.New(dialer, ports, stopChannel, readyChannel, outStream, os.Stderr)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "error creating port forwarder")
+		return nil, nil, fmt.Errorf("error creating port forwarder: %w", err)
 	}
 
 	go func() {

pkg/fission-cli/util/util.go

@@ -32,8 +32,9 @@ import (
 
 	ignore "github.com/sabhiram/go-gitignore"
 
+	"errors"
+
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -254,7 +255,7 @@ func GetResourceReqs(input cli.Input, resReqs *v1.ResourceRequirements) (*v1.Res
 		mincpu := input.Int(flagkey.RuntimeMincpu)
 		cpuRequest, err := resource.ParseQuantity(strconv.Itoa(mincpu) + "m")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse mincpu"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse mincpu: %w", err))
 		}
 		r.Requests[v1.ResourceCPU] = cpuRequest
 	}
@@ -263,7 +264,7 @@ func GetResourceReqs(input cli.Input, resReqs *v1.ResourceRequirements) (*v1.Res
 		minmem := input.Int(flagkey.RuntimeMinmemory)
 		memRequest, err := resource.ParseQuantity(strconv.Itoa(minmem) + "Mi")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse minmemory"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse minmemory: %w", err))
 		}
 		r.Requests[v1.ResourceMemory] = memRequest
 	}
@@ -272,7 +273,7 @@ func GetResourceReqs(input cli.Input, resReqs *v1.ResourceRequirements) (*v1.Res
 		maxcpu := input.Int(flagkey.RuntimeMaxcpu)
 		cpuLimit, err := resource.ParseQuantity(strconv.Itoa(maxcpu) + "m")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxcpu"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse maxcpu: %w", err))
 		}
 		r.Limits[v1.ResourceCPU] = cpuLimit
 	}
@@ -281,7 +282,7 @@ func GetResourceReqs(input cli.Input, resReqs *v1.ResourceRequirements) (*v1.Res
 		maxmem := input.Int(flagkey.RuntimeMaxmemory)
 		memLimit, err := resource.ParseQuantity(strconv.Itoa(maxmem) + "Mi")
 		if err != nil {
-			e = multierror.Append(e, errors.Wrap(err, "Failed to parse maxmemory"))
+			e = multierror.Append(e, fmt.Errorf("Failed to parse maxmemory: %w", err))
 		}
 		r.Limits[v1.ResourceMemory] = memLimit
 	}
@@ -340,7 +341,7 @@ func GetSpecIgnoreParser(specDir, specIgnore string) (ignore.IgnoreParser, error
 	if _, err := os.Stat(specIgnorePath); errors.Is(err, os.ErrNotExist) {
 		// return error if it's custom spec ignore file
 		if specIgnore != SPEC_IGNORE_FILE {
-			return nil, errors.Errorf("Spec ignore file '%s' doesn't exist. "+
+			return nil, fmt.Errorf("Spec ignore file '%s' doesn't exist. "+
 				"Please check the file path: '%s'", specIgnore, specIgnorePath)
 		}
 		return ignore.CompileIgnoreLines(), nil
@@ -423,7 +424,7 @@ func ParseAnnotations(annotations []string) (map[string]string, error) {
 		}
 	}
 	if invalidAnnotations != "" {
-		return nil, errors.Errorf("invalid annotations: %s", invalidAnnotations)
+		return nil, fmt.Errorf("invalid annotations: %s", invalidAnnotations)
 	}
 	return annotationMap, nil
 }
@@ -523,7 +524,7 @@ func GetSvcName(ctx context.Context, kClient kubernetes.Interface, application s
 	}
 
 	if len(services.Items) > 1 || len(services.Items) == 0 {
-		return "", errors.Errorf("more than one service found for application=%s", application)
+		return "", fmt.Errorf("more than one service found for application=%s", application)
 	}
 	service := services.Items[0]
 	return service.Name + "." + service.Namespace, nil
@@ -576,7 +577,7 @@ func FunctionPodLogs(ctx context.Context, fnName, ns string, client cmd.Client)
 	// get the pod with highest resource version
 	err = getContainerLog(ctx, client.KubernetesClient, f, &pods[0])
 	if err != nil {
-		return errors.Wrapf(err, "error getting container logs")
+		return fmt.Errorf("error getting container logs: %w", err)
 
 	}
 	return err
@@ -591,19 +592,19 @@ func getContainerLog(ctx context.Context, kubernetesClient kubernetes.Interface,
 
 		podLogs, err := podLogsReq.Stream(ctx)
 		if err != nil {
-			return errors.Wrapf(err, "error streaming pod log")
+			return fmt.Errorf("error streaming pod log: %w", err)
 		}
 
 		msg := fmt.Sprintf("\n%v\nFunction: %v\nEnvironment: %v\nNamespace: %v\nPod: %v\nContainer: %v\nNode: %v\n%v\n", seq,
 			fn.ObjectMeta.Name, fn.Spec.Environment.Name, pod.Namespace, pod.Name, container.Name, pod.Spec.NodeName, seq)
 
 		if _, err := io.WriteString(os.Stdout, msg); err != nil {
-			return errors.Wrapf(err, "error copying pod log")
+			return fmt.Errorf("error copying pod log: %w", err)
 		}
 
 		_, err = io.Copy(os.Stdout, podLogs)
 		if err != nil {
-			return errors.Wrapf(err, "error copying pod log")
+			return fmt.Errorf("error copying pod log: %w", err)
 		}
 
 		podLogs.Close()

pkg/kubewatcher/main.go

@@ -18,8 +18,8 @@ package kubewatcher
 
 import (
 	"context"
+	"fmt"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	"github.com/fission/fission/pkg/crd"
@@ -30,23 +30,23 @@ import (
 func Start(ctx context.Context, clientGen crd.ClientGeneratorInterface, logger *zap.Logger, mgr manager.Interface, routerUrl string) error {
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get fission client")
+		return fmt.Errorf("failed to get fission client: %w", err)
 	}
 	kubeClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get kubernetes client")
+		return fmt.Errorf("failed to get kubernetes client: %w", err)
 	}
 
 	err = crd.WaitForFunctionCRDs(ctx, logger, fissionClient)
 	if err != nil {
-		return errors.Wrap(err, "error waiting for CRDs")
+		return fmt.Errorf("error waiting for CRDs: %w", err)
 	}
 
 	poster := publisher.MakeWebhookPublisher(logger, routerUrl)
 	kubeWatch := MakeKubeWatcher(ctx, logger, kubeClient, poster)
 	ws, err := MakeWatchSync(ctx, logger, fissionClient, kubeWatch)
 	if err != nil {
-		return errors.Wrap(err, "error making watch sync")
+		return fmt.Errorf("error making watch sync: %w", err)
 	}
 	ws.Run(ctx, mgr)
 

pkg/mqtrigger/factory/factory.go

@@ -17,9 +17,9 @@ limitations under the License.
 package factory
 
 import (
+	"fmt"
 	"sync"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -56,7 +56,7 @@ func Register(mqType fv1.MessageQueueType, factory MessageQueueFactory) {
 func Create(logger *zap.Logger, mqType fv1.MessageQueueType, mqConfig messageQueue.Config, routerUrl string) (messageQueue.MessageQueue, error) {
 	factory, registered := messageQueueFactories[mqType]
 	if !registered {
-		return nil, errors.Errorf("no supported message queue type found for %q", mqType)
+		return nil, fmt.Errorf("no supported message queue type found for %q", mqType)
 	}
 	return factory.Create(logger, mqConfig, routerUrl)
 }

pkg/mqtrigger/messageQueue/kafka/consumer.go

@@ -23,8 +23,9 @@ import (
 	"strconv"
 	"strings"
 
+	"errors"
+
 	"github.com/IBM/sarama"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
@@ -215,7 +216,7 @@ func (ch *MqtConsumerGroupHandler) kafkaMsgHandler(msg *sarama.ConsumerMessage)
 		errorString := "request body error: " + string(body)
 		errorHeaders := generateErrorHeaders(errorString)
 		errorHandler(ch.logger, ch.trigger, ch.producer, ch.fnUrl,
-			errors.Wrap(err, errorString), errorHeaders)
+			fmt.Errorf("%s: %w", errorString, err), errorHeaders)
 		return
 	}
 	if resp.StatusCode != 200 {

pkg/mqtrigger/messageQueue/kafka/kafka.go

@@ -25,8 +25,9 @@ import (
 	"strconv"
 	"strings"
 
+	"errors"
+
 	"github.com/IBM/sarama"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"

pkg/mqtrigger/scalermanager.go

@@ -10,7 +10,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	appsv1 "k8s.io/api/apps/v1"
 	apiv1 "k8s.io/api/core/v1"
@@ -18,13 +17,14 @@ import (
 	"k8s.io/client-go/kubernetes"
 	k8sCache "k8s.io/client-go/tools/cache"
 
+	kedav1alpha1 "github.com/kedacore/keda/v2/apis/keda/v1alpha1"
+	kedaClient "github.com/kedacore/keda/v2/pkg/generated/clientset/versioned"
+
 	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 	"github.com/fission/fission/pkg/crd"
 	"github.com/fission/fission/pkg/executor/util"
 	"github.com/fission/fission/pkg/utils"
 	"github.com/fission/fission/pkg/utils/manager"
-	kedav1alpha1 "github.com/kedacore/keda/v2/apis/keda/v1alpha1"
-	kedaClient "github.com/kedacore/keda/v2/pkg/generated/clientset/versioned"
 )
 
 var (
@@ -103,20 +103,20 @@ func mqTriggerEventHandlers(ctx context.Context, logger *zap.Logger, kubeClient
 func StartScalerManager(ctx context.Context, clientGen crd.ClientGeneratorInterface, logger *zap.Logger, mgr manager.Interface, routerURL string) error {
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get fission client")
+		return fmt.Errorf("failed to get fission client: %w", err)
 	}
 	kubeClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get kubernetes client")
+		return fmt.Errorf("failed to get kubernetes client: %w", err)
 	}
 	kedaClient, err := clientGen.GetKedaClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get keda client")
+		return fmt.Errorf("failed to get keda client: %w", err)
 	}
 
 	err = crd.WaitForFunctionCRDs(ctx, logger, fissionClient)
 	if err != nil {
-		return errors.Wrap(err, "error waiting for CRDs")
+		return fmt.Errorf("error waiting for CRDs: %w", err)
 	}
 
 	for _, informer := range utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.MessageQueueResource) {

pkg/mqtrigger/scalermanager_test.go

@@ -12,8 +12,9 @@ import (
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/kubernetes/fake"
 
-	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 	kedav1alpha1 "github.com/kedacore/keda/v2/apis/keda/v1alpha1"
+
+	fv1 "github.com/fission/fission/pkg/apis/core/v1"
 )
 
 func Test_toEnvVar(t *testing.T) {

pkg/publisher/publisher_test.go

@@ -7,9 +7,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 	otelUtils "github.com/fission/fission/pkg/utils/otel"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestPublisher(t *testing.T) {

pkg/publisher/webhookPublisher.go

@@ -25,11 +25,12 @@ import (
 	"strings"
 	"time"
 
-	otelUtils "github.com/fission/fission/pkg/utils/otel"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.opentelemetry.io/otel"
 	"go.uber.org/zap"
 	"golang.org/x/net/context/ctxhttp"
+
+	otelUtils "github.com/fission/fission/pkg/utils/otel"
 )
 
 type (

pkg/router/functionHandler.go

@@ -29,7 +29,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"errors"
+
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 	"go.uber.org/zap"
 	k8stypes "k8s.io/apimachinery/pkg/types"

pkg/router/functionReferenceResolver.go

@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	k8sCache "k8s.io/client-go/tools/cache"
@@ -111,7 +110,7 @@ func (frr *functionReferenceResolver) resolve(trigger fv1.HTTPTrigger) (*resolve
 		}
 
 	default:
-		return nil, errors.Errorf("unrecognized function reference type %v", trigger.Spec.FunctionReference.Type)
+		return nil, fmt.Errorf("unrecognized function reference type %v", trigger.Spec.FunctionReference.Type)
 	}
 
 	// cache resolve result
@@ -145,7 +144,7 @@ func (frr *functionReferenceResolver) resolveByName(namespace, name string) (*re
 	}
 	if !isExist {
 		frr.logger.Error("function does not exists", zap.String("name", name), zap.String("namespace", namespace))
-		return nil, errors.Errorf("function %s/%s does not exist", namespace, name)
+		return nil, fmt.Errorf("function %s/%s does not exist", namespace, name)
 	}
 	f := obj.(*fv1.Function)