*: replace erroneous uses of Newf/Errorf by Wrap/Wrapf

pkg/ccl/cliccl/debug.go

@@ -330,7 +330,7 @@ func getActiveEncryptionkey(dir string) (string, string, error) {
 
  var setting enginepbccl.EncryptionSettings
  if err := protoutil.Unmarshal(entry.EncryptionSettings, &setting); err != nil {
- return "", "", fmt.Errorf("could not unmarshal encryption settings for %s: %v", keyRegistryFilename, err)
+ return "", "", errors.Wrapf(err, "could not unmarshal encryption settings for %s", keyRegistryFilename)
  }
 
  return setting.EncryptionType.String(), setting.KeyId, nil

pkg/ccl/cmdccl/enc_utils/main.go

@@ -183,7 +183,7 @@ func readFile(filename string) ([]byte, error) {
 
  data, err := ioutil.ReadFile(absPath)
  if err != nil {
- return nil, errors.Errorf("could not read %s: %v", absPath, err)
+ return nil, errors.Wrapf(err, "could not read %s", absPath)
  }
 
  reg, ok := fileRegistry[filename]
@@ -202,7 +202,7 @@ func readFile(filename string) ([]byte, error) {
 
  cipher, err := aes.NewCipher(key.rawKey)
  if err != nil {
- return nil, errors.Errorf("could not build AES cipher for file %s: %v", absPath, err)
+ return nil, errors.Wrapf(err, "could not build AES cipher for file %s", absPath)
  }
 
  size := len(data)

pkg/ccl/sqlproxyccl/denylist/watcher.go

@@ -174,11 +174,11 @@ func (l *listener) Less(than btree.Item) bool {
 func checkConnection(connection ConnectionTags, list *Denylist) error {
  ip := DenyEntity{Item: connection.IP, Type: IPAddrType}
  if err := list.Denied(ip); err != nil {
- return errors.Errorf("connection ip '%v' denied: %v", connection.IP, err)
+ return errors.Wrapf(err, "connection ip '%v' denied", connection.IP)
  }
  cluster := DenyEntity{Item: connection.Cluster, Type: ClusterType}
  if err := list.Denied(cluster); err != nil {
- return errors.Errorf("connection cluster '%v' denied: %v", connection.Cluster, err)
+ return errors.Wrapf(err, "connection cluster '%v' denied", connection.Cluster)
  }
  return nil
 }

pkg/cli/clisqlclient/conn.go

@@ -267,7 +267,7 @@ func (c *sqlConn) GetServerMetadata() (nodeID int32, version, clusterID string,
  c.clusterOrganization = row[2]
  id, err := strconv.Atoi(row[0])
  if err != nil {
- return 0, "", "", errors.Newf("incorrect data while retrieving node id: %v", err)
+ return 0, "", "", errors.Wrap(err, "incorrect data while retrieving node id")
  }
  nodeID = int32(id)
 

pkg/cli/doctor.go

@@ -344,12 +344,12 @@ func fromZipDir(
  last := len(fields) - 1
  i, err := strconv.Atoi(fields[0])
  if err != nil {
- return errors.Errorf("failed to parse descriptor id %s: %v", fields[0], err)
+ return errors.Wrapf(err, "failed to parse descriptor id %s", fields[0])
  }
 
  descBytes, err := hx.DecodeString(fields[last])
  if err != nil {
- return errors.Errorf("failed to decode hex descriptor %d: %v", i, err)
+ return errors.Wrapf(err, "failed to decode hex descriptor %d", i)
  }
  ts := hlc.Timestamp{WallTime: timeutil.Now().UnixNano()}
  descTable = append(descTable, doctor.DescriptorTableRow{ID: int64(i), DescBytes: descBytes, ModTime: ts})
@@ -375,18 +375,18 @@ func fromZipDir(
  fields := strings.Fields(row)
  parID, err := strconv.Atoi(fields[0])
  if err != nil {
- return errors.Errorf("failed to parse parent id %s: %v", fields[0], err)
+ return errors.Wrapf(err, "failed to parse parent id %s", fields[0])
  }
  parSchemaID, err := strconv.Atoi(fields[1])
  if err != nil {
- return errors.Errorf("failed to parse parent schema id %s: %v", fields[1], err)
+ return errors.Wrapf(err, "failed to parse parent schema id %s", fields[1])
  }
  id, err := strconv.Atoi(fields[3])
  if err != nil {
  if fields[3] == "NULL" {
  id = int(descpb.InvalidID)
  } else {
- return errors.Errorf("failed to parse id %s: %v", fields[3], err)
+ return errors.Wrapf(err, "failed to parse id %s", fields[3])
  }
  }
 
@@ -415,22 +415,22 @@ func fromZipDir(
 
  id, err := strconv.Atoi(fields[0])
  if err != nil {
- return errors.Errorf("failed to parse job id %s: %v", fields[0], err)
+ return errors.Wrapf(err, "failed to parse job id %s", fields[0])
  }
  md.ID = jobspb.JobID(id)
 
  last := len(fields) - 1
  payloadBytes, err := hx.DecodeString(fields[last-1])
  if err != nil {
- return errors.Errorf("job %d: failed to decode hex payload: %v", id, err)
+ return errors.Wrapf(err, "job %d: failed to decode hex payload", id)
  }
  md.Payload = &jobspb.Payload{}
  if err := protoutil.Unmarshal(payloadBytes, md.Payload); err != nil {
  return errors.Wrap(err, "failed unmarshalling job payload")
  }
  progressBytes, err := hx.DecodeString(fields[last])
  if err != nil {
- return errors.Errorf("job %d: failed to decode hex progress: %v", id, err)
+ return errors.Wrapf(err, "job %d: failed to decode hex progress", id)
  }
  md.Progress = &jobspb.Progress{}
  if err := protoutil.Unmarshal(progressBytes, md.Progress); err != nil {

pkg/geo/geomfn/node.go

@@ -15,7 +15,7 @@ import (
  "github.com/cockroachdb/cockroach/pkg/geo/geopb"
  "github.com/cockroachdb/cockroach/pkg/geo/geos"
  "github.com/cockroachdb/errors"
- "github.com/twpayne/go-geom"
+ geom "github.com/twpayne/go-geom"
  "github.com/twpayne/go-geom/xy"
 )
 
@@ -55,11 +55,11 @@ func Node(g geo.Geometry) (geo.Geometry, error) {
 
  glines, err := lines.AsGeomT()
  if err != nil {
- return geo.Geometry{}, errors.Newf("error transforming lines: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error transforming lines")
  }
  ep, err := extractEndpoints(g)
  if err != nil {
- return geo.Geometry{}, errors.Newf("error extracting endpoints: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error extracting endpoints")
  }
  var mllines *geom.MultiLineString
  switch t := glines.(type) {
@@ -77,7 +77,7 @@ func Node(g geo.Geometry) (geo.Geometry, error) {
 
  gep, err := ep.AsGeomT()
  if err != nil {
- return geo.Geometry{}, errors.Newf("error transforming endpoints: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error transforming endpoints")
  }
  mpep := gep.(*geom.MultiPoint)
  mlout, err := splitLinesByPoints(mllines, mpep)
@@ -87,7 +87,7 @@ func Node(g geo.Geometry) (geo.Geometry, error) {
  mlout.SetSRID(int(g.SRID()))
  out, err := geo.MakeGeometryFromGeomT(mlout)
  if err != nil {
- return geo.Geometry{}, errors.Newf("could not transform output into geometry: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "could not transform output into geometry")
  }
  return out, nil
 }
@@ -108,24 +108,24 @@ func splitLinesByPoints(
  p := mpep.Point(j)
  splitted, splitLines, err = splitLineByPoint(l, p.Coords())
  if err != nil {
- return nil, errors.Newf("could not split line: %v", err)
+ return nil, errors.Wrap(err, "could not split line")
  }
  if splitted {
  err = mlout.Push(splitLines[0])
  if err != nil {
- return nil, errors.Newf("could not construct output geometry: %v", err)
+ return nil, errors.Wrap(err, "could not construct output geometry")
  }
  err = mlout.Push(splitLines[1])
  if err != nil {
- return nil, errors.Newf("could not construct output geometry: %v", err)
+ return nil, errors.Wrap(err, "could not construct output geometry")
  }
  break
  }
  }
  if !splitted {
  err = mlout.Push(l)
  if err != nil {
- return nil, errors.Newf("could not construct output geometry: %v", err)
+ return nil, errors.Wrap(err, "could not construct output geometry")
  }
  }
  }
@@ -138,7 +138,7 @@ func extractEndpoints(g geo.Geometry) (geo.Geometry, error) {
 
  gt, err := g.AsGeomT()
  if err != nil {
- return geo.Geometry{}, errors.Newf("error transforming geometry: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error transforming geometry")
  }
 
  switch gt := gt.(type) {
@@ -147,7 +147,7 @@ func extractEndpoints(g geo.Geometry) (geo.Geometry, error) {
  for _, endpoint := range endpoints {
  err := mp.Push(endpoint)
  if err != nil {
- return geo.Geometry{}, errors.Newf("error creating output geometry: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error creating output geometry")
  }
  }
  case *geom.MultiLineString:
@@ -157,7 +157,7 @@ func extractEndpoints(g geo.Geometry) (geo.Geometry, error) {
  for _, endpoint := range endpoints {
  err := mp.Push(endpoint)
  if err != nil {
- return geo.Geometry{}, errors.Newf("error creating output geometry: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error creating output geometry")
  }
  }
  }
@@ -167,7 +167,7 @@ func extractEndpoints(g geo.Geometry) (geo.Geometry, error) {
 
  result, err := geo.MakeGeometryFromGeomT(mp)
  if err != nil {
- return geo.Geometry{}, errors.Newf("error creating output geometry: %v", err)
+ return geo.Geometry{}, errors.Wrap(err, "error creating output geometry")
  }
  return result, nil
 }
@@ -212,12 +212,12 @@ func splitLineByPoint(l *geom.LineString, p geom.Coord) (bool, []*geom.LineStrin
  l1 := geom.NewLineString(l.Layout())
  _, err := l1.SetCoords(coordsA)
  if err != nil {
- return false, []*geom.LineString{}, errors.Newf("could not set coords: %v", err)
+ return false, []*geom.LineString{}, errors.Wrap(err, "could not set coords")
  }
  l2 := geom.NewLineString(l.Layout())
  _, err = l2.SetCoords(coordsB)
  if err != nil {
- return false, []*geom.LineString{}, errors.Newf("could not set coords: %v", err)
+ return false, []*geom.LineString{}, errors.Wrap(err, "could not set coords")
  }
  return true, []*geom.LineString{l1, l2}, nil
 }

pkg/geo/geomfn/subdivide.go

@@ -15,7 +15,7 @@ import (
 
  "github.com/cockroachdb/cockroach/pkg/geo"
  "github.com/cockroachdb/errors"
- "github.com/twpayne/go-geom"
+ geom "github.com/twpayne/go-geom"
 )
 
 // Subdivide returns a geometry divided into parts, where each part contains no more than the number of vertices provided.
@@ -30,11 +30,11 @@ func Subdivide(g geo.Geometry, maxVertices int) ([]geo.Geometry, error) {
 
  gt, err := g.AsGeomT()
  if err != nil {
- return nil, errors.Newf("could not transform input geometry into geom.T: %v", err)
+ return nil, errors.Wrap(err, "could not transform input geometry into geom.T")
  }
  dim, err := dimensionFromGeomT(gt)
  if err != nil {
- return nil, errors.Newf("could not calculate geometry dimension: %v", err)
+ return nil, errors.Wrap(err, "could not calculate geometry dimension")
  }
  // maxDepth 50 => 2^50 ~= 10^15 subdivisions.
  const maxDepth = 50
@@ -49,7 +49,7 @@ func Subdivide(g geo.Geometry, maxVertices int) ([]geo.Geometry, error) {
  geo.AdjustGeomTSRID(cg, g.SRID())
  g, err := geo.MakeGeometryFromGeomT(cg)
  if err != nil {
- return []geo.Geometry{}, errors.Newf("could not transform output geom.T into geometry: %v", err)
+ return []geo.Geometry{}, errors.Wrap(err, "could not transform output geom.T into geometry")
  }
  output = append(output, g)
  }
@@ -106,7 +106,7 @@ func subdivideRecursive(
  }
  currDim, err := dimensionFromGeomT(gt)
  if err != nil {
- return nil, errors.Newf("error checking geom.T dimension: %v", err)
+ return nil, errors.Wrap(err, "error checking geom.T dimension")
  }
  if currDim < dim {
  // Ignore lower dimension object produced by clipping at a shallower recursion level.
@@ -142,11 +142,11 @@ func subdivideRecursive(
 
  clipped1, err := clipGeomTByBoundingBoxForSubdivide(gt, &subBox1)
  if err != nil {
- return nil, errors.Newf("error clipping geom.T: %v", err)
+ return nil, errors.Wrap(err, "error clipping geom.T")
  }
  clipped2, err := clipGeomTByBoundingBoxForSubdivide(gt, &subBox2)
  if err != nil {
- return nil, errors.Newf("error clipping geom.T: %v", err)
+ return nil, errors.Wrap(err, "error clipping geom.T")
  }
  depth++
  subdivisions1, err := subdivideRecursive(clipped1, maxVertices, depth, dim, maxDepth)
@@ -207,7 +207,7 @@ func calculateSplitPointCoordForSubdivide(
  var err error
  pivot, err = findMostCentralPointValueForPolygon(gt, nVertices, splitHorizontally, &clip)
  if err != nil {
- return 0, errors.Newf("error finding most central point for polygon: %v", err)
+ return 0, errors.Wrap(err, "error finding most central point for polygon")
  }
  if splitHorizontally {
  // Ignore point on the boundaries
@@ -278,25 +278,25 @@ func findMostCentralPointValueForPolygon(
 func clipGeomTByBoundingBoxForSubdivide(gt geom.T, clip *geo.CartesianBoundingBox) (geom.T, error) {
  g, err := geo.MakeGeometryFromGeomT(gt)
  if err != nil {
- return nil, errors.Newf("error transforming geom.T to geometry: %v", err)
+ return nil, errors.Wrap(err, "error transforming geom.T to geometry")
  }
  clipgt := clip.ToGeomT(g.SRID())
  clipg, err := geo.MakeGeometryFromGeomT(clipgt)
  if err != nil {
- return nil, errors.Newf("error transforming geom.T to geometry: %v", err)
+ return nil, errors.Wrap(err, "error transforming geom.T to geometry")
  }
  out, err := Intersection(g, clipg)
  if err != nil {
- return nil, errors.Newf("error applying intersection: %v", err)
+ return nil, errors.Wrap(err, "error applying intersection")
  }
  // Simplify is required to remove the unnecessary points. Otherwise vertices count is altered and too many subdivision may be returned.
  out, err = SimplifyGEOS(out, 0)
  if err != nil {
- return nil, errors.Newf("simplifying error: %v", err)
+ return nil, errors.Wrap(err, "simplifying error")
  }
  gt, err = out.AsGeomT()
  if err != nil {
- return nil, errors.Newf("error transforming geometry to geom.T: %v", err)
+ return nil, errors.Wrap(err, "error transforming geometry to geom.T")
  }
  return gt, nil
 }

pkg/geo/parse.go

@@ -20,7 +20,7 @@ import (
  "github.com/cockroachdb/cockroach/pkg/util"
  "github.com/cockroachdb/errors"
  "github.com/pierrre/geohash"
- "github.com/twpayne/go-geom"
+ geom "github.com/twpayne/go-geom"
  "github.com/twpayne/go-geom/encoding/ewkb"
  "github.com/twpayne/go-geom/encoding/ewkbhex"
  "github.com/twpayne/go-geom/encoding/geojson"
@@ -247,7 +247,7 @@ func parseGeoHash(g string, precision int) (geohash.Box, error) {
 func GeometryToEncodedPolyline(g Geometry, p int) (string, error) {
  gt, err := g.AsGeomT()
  if err != nil {
- return "", fmt.Errorf("error parsing input geometry: %v", err)
+ return "", errors.Wrap(err, "error parsing input geometry")
  }
  if gt.SRID() != 4326 {
  return "", errors.New("only SRID 4326 is supported")
@@ -263,7 +263,7 @@ func ParseEncodedPolyline(encodedPolyline string, precision int) (Geometry, erro
 
  g, err := MakeGeometryFromGeomT(ls)
  if err != nil {
- return Geometry{}, fmt.Errorf("parsing geography error: %v", err)
+ return Geometry{}, errors.Wrap(err, "parsing geography error")
  }
  return g, nil
 }

pkg/gossip/gossip.go

@@ -404,7 +404,7 @@ func (g *Gossip) SetNodeDescriptor(desc *roachpb.NodeDescriptor) error {
  log.Fatalf(ctx, "n%d address is empty", desc.NodeID)
  }
  if err := g.AddInfoProto(MakeNodeIDKey(desc.NodeID), desc, NodeDescriptorTTL); err != nil {
- return errors.Errorf("n%d: couldn't gossip descriptor: %v", desc.NodeID, err)
+ return errors.Wrapf(err, "n%d: couldn't gossip descriptor", desc.NodeID)
  }
  g.updateClients()
  return nil

pkg/kv/kvserver/store_snapshot.go

@@ -1155,7 +1155,10 @@ func sendSnapshot(
  // completed (such as defers that might be run after the previous message was
  // received).
  if unexpectedResp, err := stream.Recv(); err != io.EOF {
- return errors.Errorf("%s: expected EOF, got resp=%v err=%v", to, unexpectedResp, err)
+ if err != nil {
+ return errors.Wrapf(err, "%s: expected EOF, got resp=%v with error", to, unexpectedResp)
+ }
+ return errors.Newf("%s: expected EOF, got resp=%v", to, unexpectedResp)
  }
  switch resp.Status {
  case SnapshotResponse_ERROR:

pkg/kv/kvserver/store_split.go

@@ -21,7 +21,7 @@ import (
  "github.com/cockroachdb/cockroach/pkg/util/hlc"
  "github.com/cockroachdb/cockroach/pkg/util/log"
  "github.com/cockroachdb/errors"
- "go.etcd.io/etcd/raft/v3"
+ raft "go.etcd.io/etcd/raft/v3"
  "go.etcd.io/etcd/raft/v3/raftpb"
 )
 
@@ -335,7 +335,7 @@ func (s *Store) SplitRange(
  rightRepl := rightReplOrNil
  leftRepl.writeStats.splitRequestCounts(rightRepl.writeStats)
  if err := s.addReplicaInternalLocked(rightRepl); err != nil {
- return errors.Errorf("unable to add replica %v: %s", rightRepl, err)
+ return errors.Wrapf(err, "unable to add replica %v", rightRepl)
  }
 
  // Update the replica's cached byte thresholds. This is a no-op if the system