Replace github.com/pkg/errors with native libraries

Signed-off-by: u5surf <[email protected]>

Gopkg.toml

@@ -83,10 +83,6 @@ required = [
   name = "github.com/opentracing/opentracing-go"
   version = "^1.0.2"
 
-[[constraint]]
-  name = "github.com/pkg/errors"
-  version = "^0.8.0"
-
 [[constraint]]
   name = "github.com/prometheus/client_golang"
   version = "^1"

cmd/agent/app/builder.go

@@ -21,7 +21,6 @@ import (
 	"strconv"
 
 	"github.com/apache/thrift/lib/go/thrift"
-	"github.com/pkg/errors"
 	"github.com/uber/jaeger-lib/metrics"
 	"go.uber.org/zap"
 
@@ -110,7 +109,7 @@ func (b *Builder) CreateAgent(primaryProxy CollectorProxy, logger *zap.Logger, m
 	r := b.getReporter(primaryProxy)
 	processors, err := b.getProcessors(r, mFactory, logger)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot create processors")
+		return nil, fmt.Errorf("cannot create processors: %w", err)
 	}
 	server := b.HTTPServer.getHTTPServer(primaryProxy.GetManager(), mFactory)
 	return NewAgent(processors, server, logger), nil
@@ -150,7 +149,7 @@ func (b *Builder) getProcessors(rep reporter.Reporter, mFactory metrics.Factory,
 		}})
 		processor, err := cfg.GetThriftProcessor(metrics, protoFactory, handler, logger)
 		if err != nil {
-			return nil, errors.Wrap(err, "cannot create Thrift Processor")
+			return nil, fmt.Errorf("cannot create Thrift Processor: %w", err)
 		}
 		retMe[idx] = processor
 	}
@@ -176,7 +175,7 @@ func (c *ProcessorConfiguration) GetThriftProcessor(
 
 	server, err := c.Server.getUDPServer(mFactory)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot create UDP Server")
+		return nil, fmt.Errorf("cannot create UDP Server: %w", err)
 	}
 
 	return processors.NewThriftProcessor(server, c.Workers, mFactory, factory, handler, logger)
@@ -200,7 +199,7 @@ func (c *ServerConfiguration) getUDPServer(mFactory metrics.Factory) (servers.Se
 	}
 	transport, err := thriftudp.NewTUDPServerTransport(c.HostPort)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot create UDPServerTransport")
+		return nil, fmt.Errorf("cannot create UDPServerTransport: %w", err)
 	}
 
 	return servers.NewTBufferedServer(transport, c.QueueSize, c.MaxPacketSize, mFactory)

cmd/agent/app/reporter/grpc/builder.go

@@ -15,10 +15,11 @@
 package grpc
 
 import (
+	"errors"
+	"fmt"
 	"strings"
 
 	grpc_retry "github.com/grpc-ecosystem/go-grpc-middleware/retry"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -56,7 +57,7 @@ func (b *ConnBuilder) CreateConnection(logger *zap.Logger) (*grpc.ClientConn, er
 		logger.Info("Agent requested secure grpc connection to collector(s)")
 		tlsConf, err := b.TLS.Config()
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to load TLS config")
+			return nil, fmt.Errorf("failed to load TLS config: %w", err)
 		}
 
 		creds := credentials.NewTLS(tlsConf)

cmd/agent/app/reporter/grpc/collector_proxy.go

@@ -22,7 +22,6 @@ import (
 	"github.com/jaegertracing/jaeger/cmd/agent/app/configmanager"
 	grpcManager "github.com/jaegertracing/jaeger/cmd/agent/app/configmanager/grpc"
 	"github.com/jaegertracing/jaeger/cmd/agent/app/reporter"
-	aReporter "github.com/jaegertracing/jaeger/cmd/agent/app/reporter"
 )
 
 // ProxyBuilder holds objects communicating with collector
@@ -59,7 +58,7 @@ func (b ProxyBuilder) GetConn() *grpc.ClientConn {
 }
 
 // GetReporter returns Reporter
-func (b ProxyBuilder) GetReporter() aReporter.Reporter {
+func (b ProxyBuilder) GetReporter() reporter.Reporter {
 	return b.reporter
 }
 

cmd/agent/app/reporter/tchannel/builder.go

@@ -16,9 +16,10 @@
 package tchannel
 
 import (
+	"errors"
+	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
 	tchannel "github.com/uber/tchannel-go"
 	"go.uber.org/zap"
 
@@ -129,7 +130,7 @@ func (b *Builder) CreateReporter(logger *zap.Logger) (*Reporter, error) {
 
 	peerListMgr, err := b.enableDiscovery(b.channel, logger)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot enable service discovery")
+		return nil, fmt.Errorf("cannot enable service discovery: %w", err)
 	}
 	return New(b.CollectorServiceName, b.channel, b.ReportTimeout, peerListMgr, logger), nil
 }

cmd/agent/main.go

@@ -20,7 +20,6 @@ import (
 	"io"
 	"os"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/uber/jaeger-lib/metrics"
@@ -69,12 +68,12 @@ func main() {
 			builder := new(app.Builder).InitFromViper(v)
 			agent, err := builder.CreateAgent(cp, logger, mFactory)
 			if err != nil {
-				return errors.Wrap(err, "unable to initialize Jaeger Agent")
+				return fmt.Errorf("unable to initialize Jaeger Agent: %w", err)
 			}
 
 			logger.Info("Starting agent")
 			if err := agent.Run(); err != nil {
-				return errors.Wrap(err, "failed to run the agent")
+				return fmt.Errorf("failed to run the agent: %w", err)
 			}
 			svc.RunAndThen(func() {
 				if closer, ok := cp.(io.Closer); ok {

cmd/collector/app/server/grpc.go

@@ -15,12 +15,12 @@
 package server
 
 import (
+	"fmt"
 	"io/ioutil"
 	"net"
 	"os"
 	"strconv"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -65,7 +65,7 @@ func StartGRPCServer(params *GRPCServerParams) (*grpc.Server, error) {
 	grpcPortStr := ":" + strconv.Itoa(params.Port)
 	listener, err := net.Listen("tcp", grpcPortStr)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to listen on gRPC port")
+		return nil, fmt.Errorf("failed to listen on gRPC port: %w", err)
 	}
 
 	if err := serveGRPC(server, listener, params); err != nil {

cmd/flags/flags.go

@@ -17,10 +17,10 @@ package flags
 
 import (
 	"flag"
+	"fmt"
 	"os"
 	"strings"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/viper"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
@@ -43,7 +43,7 @@ func TryLoadConfigFile(v *viper.Viper) error {
 		v.SetConfigFile(file)
 		err := v.ReadInConfig()
 		if err != nil {
-			return errors.Wrapf(err, "cannot load config file %s", file)
+			return fmt.Errorf("cannot load config file %s: %w", file, err)
 		}
 	}
 	return nil

cmd/flags/service.go

@@ -16,12 +16,12 @@ package flags
 
 import (
 	"flag"
+	"fmt"
 	"os"
 	"os/signal"
 	"syscall"
 
 	grpcZap "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap"
-	"github.com/pkg/errors"
 	"github.com/spf13/viper"
 	"github.com/uber/jaeger-lib/metrics"
 	"go.uber.org/zap"
@@ -85,7 +85,7 @@ func (s *Service) SetHealthCheckStatus(status healthcheck.Status) {
 // Start bootstraps the service and starts the admin server.
 func (s *Service) Start(v *viper.Viper) error {
 	if err := TryLoadConfigFile(v); err != nil {
-		return errors.Wrap(err, "cannot load config file")
+		return fmt.Errorf("cannot load config file: %w", err)
 	}
 
 	sFlags := new(SharedFlags).InitFromViper(v)
@@ -99,13 +99,13 @@ func (s *Service) Start(v *viper.Viper) error {
 			zap.AddCallerSkip(3),
 		))
 	} else {
-		return errors.Wrap(err, "cannot create logger")
+		return fmt.Errorf("cannot create logger: %w", err)
 	}
 
 	metricsBuilder := new(pMetrics.Builder).InitFromViper(v)
 	metricsFactory, err := metricsBuilder.CreateMetricsFactory("")
 	if err != nil {
-		return errors.Wrap(err, "cannot create metrics factory")
+		return fmt.Errorf("cannot create metrics factory: %w", err)
 	}
 	s.MetricsFactory = metricsFactory
 
@@ -116,7 +116,7 @@ func (s *Service) Start(v *viper.Viper) error {
 		s.Admin.Handle(route, h)
 	}
 	if err := s.Admin.Serve(); err != nil {
-		return errors.Wrap(err, "cannot start the admin server")
+		return fmt.Errorf("cannot start the admin server: %w", err)
 	}
 
 	return nil

cmd/ingester/app/consumer/consumer_test.go

@@ -15,15 +15,15 @@
 package consumer
 
 import (
+	"errors"
 	"fmt"
 	"sync"
 	"testing"
 	"time"
 
 	"github.com/Shopify/sarama"
 	smocks "github.com/Shopify/sarama/mocks"
-	"github.com/bsm/sarama-cluster"
-	"github.com/pkg/errors"
+	cluster "github.com/bsm/sarama-cluster"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"

cmd/ingester/app/processor/metrics_decorator_test.go

@@ -15,9 +15,9 @@
 package processor_test
 
 import (
+	"errors"
 	"testing"
 
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/uber/jaeger-lib/metrics/metricstest"
 

cmd/ingester/app/processor/span_processor.go

@@ -15,10 +15,9 @@
 package processor
 
 import (
+	"fmt"
 	"io"
 
-	"github.com/pkg/errors"
-
 	"github.com/jaegertracing/jaeger/plugin/storage/kafka"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
@@ -61,7 +60,7 @@ func NewSpanProcessor(params SpanProcessorParams) *KafkaSpanProcessor {
 func (s KafkaSpanProcessor) Process(message Message) error {
 	mSpan, err := s.unmarshaller.Unmarshal(message.Value())
 	if err != nil {
-		return errors.Wrap(err, "cannot unmarshall byte array into span")
+		return fmt.Errorf("cannot unmarshall byte array into span: %w", err)
 	}
 	return s.writer.WriteSpan(mSpan)
 }

cmd/ingester/app/processor/span_processor_test.go

@@ -15,9 +15,9 @@
 package processor
 
 import (
+	"errors"
 	"testing"
 
-	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
 
 	cmocks "github.com/jaegertracing/jaeger/cmd/ingester/app/consumer/mocks"

cmd/query/app/http_handler.go

@@ -27,7 +27,6 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/opentracing-contrib/go-stdlib/nethttp"
 	"github.com/opentracing/opentracing-go"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
@@ -263,13 +262,19 @@ func (aH *APIHandler) tracesByIDs(ctx context.Context, traceIDs []model.TraceID)
 
 func (aH *APIHandler) dependencies(w http.ResponseWriter, r *http.Request) {
 	endTsMillis, err := strconv.ParseInt(r.FormValue(endTsParam), 10, 64)
-	if aH.handleError(w, errors.Wrapf(err, "unable to parse %s", endTimeParam), http.StatusBadRequest) {
+	if err != nil {
+		err = fmt.Errorf("unable to parse %s: %w", endTimeParam, err)
+	}
+	if aH.handleError(w, err, http.StatusBadRequest) {
 		return
 	}
 	var lookback time.Duration
 	if formValue := r.FormValue(lookbackParam); len(formValue) > 0 {
 		lookback, err = time.ParseDuration(formValue + "ms")
-		if aH.handleError(w, errors.Wrapf(err, "unable to parse %s", lookbackParam), http.StatusBadRequest) {
+		if err != nil {
+			err = fmt.Errorf("unable to parse %s: %w", lookbackParam, err)
+		}
+		if aH.handleError(w, err, http.StatusBadRequest) {
 			return
 		}
 	}

cmd/query/app/query_parser.go

@@ -23,8 +23,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
-
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
@@ -121,7 +119,7 @@ func (p *queryParser) parse(r *http.Request) (*traceQueryParameters, error) {
 		if traceID, err := model.TraceIDFromString(id); err == nil {
 			traceIDs = append(traceIDs, traceID)
 		} else {
-			return nil, errors.Wrap(err, "cannot parse traceID param")
+			return nil, fmt.Errorf("cannot parse traceID param: %w", err)
 		}
 	}
 
@@ -165,7 +163,7 @@ func (p *queryParser) parseDuration(durationParam string, r *http.Request) (time
 	if len(durationInput) > 0 {
 		duration, err := time.ParseDuration(durationInput)
 		if err != nil {
-			return 0, errors.Wrapf(err, "cannot not parse %s", durationParam)
+			return 0, fmt.Errorf("cannot not parse %s: %w", durationParam, err)
 		}
 		return duration, nil
 	}

cmd/query/app/static_handler.go

@@ -27,7 +27,6 @@ import (
 
 	"github.com/fsnotify/fsnotify"
 	"github.com/gorilla/mux"
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/cmd/query/app/ui"
@@ -101,7 +100,7 @@ func NewStaticAssetsHandler(staticAssetsRoot string, options StaticAssetsHandler
 func loadIndexBytes(open func(string) (http.File, error), options StaticAssetsHandlerOptions) ([]byte, error) {
 	indexBytes, err := loadIndexHTML(open)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot load index.html")
+		return nil, fmt.Errorf("cannot load index.html: %w", err)
 	}
 	configString := "JAEGER_CONFIG = DEFAULT_CONFIG"
 	if config, err := loadUIConfig(options.UIConfigPath); err != nil {
@@ -188,12 +187,12 @@ func (sH *StaticAssetsHandler) watch() {
 func loadIndexHTML(open func(string) (http.File, error)) ([]byte, error) {
 	indexFile, err := open("/index.html")
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot open index.html")
+		return nil, fmt.Errorf("cannot open index.html: %w", err)
 	}
 	defer indexFile.Close()
 	indexBytes, err := ioutil.ReadAll(indexFile)
 	if err != nil {
-		return nil, errors.Wrap(err, "cannot read from index.html")
+		return nil, fmt.Errorf("cannot read from index.html: %w", err)
 	}
 	return indexBytes, nil
 }
@@ -205,7 +204,7 @@ func loadUIConfig(uiConfig string) (map[string]interface{}, error) {
 	ext := filepath.Ext(uiConfig)
 	bytes, err := ioutil.ReadFile(uiConfig) /* nolint #nosec , this comes from an admin, not user */
 	if err != nil {
-		return nil, errors.Wrapf(err, "cannot read UI config file %v", uiConfig)
+		return nil, fmt.Errorf("cannot read UI config file %v: %w", uiConfig, err)
 	}
 
 	var c map[string]interface{}
@@ -219,7 +218,7 @@ func loadUIConfig(uiConfig string) (map[string]interface{}, error) {
 	}
 
 	if err := unmarshal(bytes, &c); err != nil {
-		return nil, errors.Wrapf(err, "cannot parse UI config file %v", uiConfig)
+		return nil, fmt.Errorf("cannot parse UI config file %v: %w", uiConfig, err)
 	}
 	return c, nil
 }