Added wrapping errors with stacktrace

Author: asmyasnikov

balancers/config.go

@@ -57,7 +57,7 @@ func CreateFromConfig(config string) (balancer.Balancer, error) {
 	)
 
 	if err = json.Unmarshal([]byte(config), &c); err != nil {
-		return nil, err
+		return nil, errors.WithStackTrace(err)
 	}
 
 	switch c.Type {

cmd/gtrace/main.go

@@ -20,6 +20,8 @@ import (
 	"text/tabwriter"
 
 	_ "unsafe" // For go:linkname.
+
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/errors"
 )
 
 //go:linkname build_goodOSArchFile go/build.(*Context).goodOSArchFile
@@ -398,7 +400,7 @@ func buildFunc(info types.Info, traces map[string]*Trace, fn *ast.FuncType) (ret
 	case *ast.FuncType:
 		result, err := buildFunc(info, traces, x)
 		if err != nil {
-			return nil, err
+			return nil, errors.WithStackTrace(err)
 		}
 		ret.Result = append(ret.Result, result)
 		return ret, nil
@@ -577,7 +579,7 @@ func scanBuildConstraints(r io.Reader) (cs []string, err error) {
 	for {
 		line, err := br.ReadBytes('\n')
 		if err != nil {
-			return nil, err
+			return nil, errors.WithStackTrace(err)
 		}
 		line = bytes.TrimSpace(line)
 		if comm := bytes.TrimPrefix(line, []byte("//")); !bytes.Equal(comm, line) {

internal/conn/conn.go

@@ -8,24 +8,21 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/ydb-platform/ydb-go-genproto/protos/Ydb"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/connectivity"
-	grpcStatus "google.golang.org/grpc/status"
-
-	"github.com/ydb-platform/ydb-go-genproto/protos/Ydb"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/endpoint"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/errors"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/response"
 	"github.com/ydb-platform/ydb-go-sdk/v3/trace"
 )
 
-// nolint:gofumpt
-// nolint:nolintlint
 var (
-	// ErrOperationNotReady specified error when operation is not ready
-	ErrOperationNotReady = fmt.Errorf("operation is not ready yet")
+	// errOperationNotReady specified error when operation is not ready
+	errOperationNotReady = fmt.Errorf("operation is not ready yet")
+	// errClosedConnection specified error when connection are closed early
+	errClosedConnection = fmt.Errorf("connection closed early")
 )
 
 type Conn interface {
@@ -189,10 +186,7 @@ func (c *conn) take(ctx context.Context) (cc *grpc.ClientConn, err error) {
 	}()
 
 	if c.isClosed() {
-		return nil, errors.NewGrpcError(
-			errors.WithStatus(grpcStatus.New(codes.Unavailable, "ydb driver conn closed early")),
-			errors.WithErr(err),
-		)
+		return nil, errors.WithStackTrace(errClosedConnection)
 	}
 
 	c.mtx.Lock()
@@ -283,7 +277,7 @@ func (c *conn) close() (err error) {
 	err = c.cc.Close()
 	c.cc = nil
 	c.setState(Offline)
-	return err
+	return errors.WithStackTrace(err)
 }
 
 func (c *conn) isClosed() bool {
@@ -319,42 +313,7 @@ func (c *conn) Close(ctx context.Context) (err error) {
 		f(c)
 	}
 
-	return err
-}
-
-// invoke have behavior like grpc call
-func (c *conn) invoke(
-	ctx context.Context,
-	method string,
-	req interface{},
-	res interface{},
-	opts ...grpc.CallOption,
-) (err error) {
-	var cc *grpc.ClientConn
-	cc, err = c.take(ctx)
-	if err != nil {
-		return errors.NewGrpcError(
-			errors.WithStatus(grpcStatus.New(codes.Unavailable, "ydb driver conn take failed")),
-			errors.WithErr(err),
-		)
-	}
-
-	c.changeUsages(1)
-	defer c.changeUsages(-1)
-
-	err = cc.Invoke(ctx, method, req, res, opts...)
-
-	if err != nil {
-		if s, ok := grpcStatus.FromError(err); ok {
-			return errors.NewGrpcError(
-				errors.WithStatus(s),
-				errors.WithErr(errors.WithStackTrace(err)),
-			)
-		}
-		return errors.WithStackTrace(err)
-	}
-
-	return nil
+	return errors.WithStackTrace(err)
 }
 
 func (c *conn) Invoke(
@@ -374,13 +333,22 @@ func (c *conn) Invoke(
 			c.endpoint,
 			trace.Method(method),
 		)
+		cc *grpc.ClientConn
 	)
 
 	defer func() {
 		onDone(err, issues, opID, c.GetState())
 	}()
 
-	err = c.invoke(ctx, method, req, res, opts...)
+	cc, err = c.take(ctx)
+	if err != nil {
+		return errors.WithStackTrace(err)
+	}
+
+	c.changeUsages(1)
+	defer c.changeUsages(-1)
+
+	err = cc.Invoke(ctx, method, req, res, opts...)
 
 	if err != nil {
 		if wrapping {
@@ -391,7 +359,7 @@ func (c *conn) Invoke(
 				),
 			)
 		}
-		return err
+		return errors.WithStackTrace(err)
 	}
 
 	if o, ok := res.(response.Response); ok {
@@ -402,52 +370,23 @@ func (c *conn) Invoke(
 		if wrapping {
 			switch {
 			case !o.GetOperation().GetReady():
-				return errors.WithStackTrace(ErrOperationNotReady)
+				return errors.WithStackTrace(errOperationNotReady)
 
 			case o.GetOperation().GetStatus() != Ydb.StatusIds_SUCCESS:
-				return errors.WithStackTrace(errors.NewOpError(errors.WithOEOperation(o.GetOperation())))
+				return errors.WithStackTrace(
+					errors.NewOpError(
+						errors.WithOEOperation(
+							o.GetOperation(),
+						),
+					),
+				)
 			}
 		}
 	}
 
 	return err
 }
 
-// newStream have behavior like grpc call
-func (c *conn) newStream(
-	ctx context.Context,
-	desc *grpc.StreamDesc,
-	method string,
-	opts ...grpc.CallOption,
-) (_ grpc.ClientStream, err error) {
-	var cc *grpc.ClientConn
-	cc, err = c.take(ctx)
-	if err != nil {
-		return nil, errors.NewGrpcError(
-			errors.WithStatus(grpcStatus.New(codes.Unavailable, "ydb driver conn take failed")),
-			errors.WithErr(err),
-		)
-	}
-
-	c.changeStreamUsages(1)
-	defer c.changeStreamUsages(-1)
-
-	var client grpc.ClientStream
-	client, err = cc.NewStream(ctx, desc, method, opts...)
-
-	if err != nil {
-		if s, ok := grpcStatus.FromError(err); ok {
-			return nil, errors.NewGrpcError(
-				errors.WithStatus(s),
-				errors.WithErr(errors.WithStackTrace(err)),
-			)
-		}
-		return nil, errors.WithStackTrace(err)
-	}
-
-	return client, nil
-}
-
 func (c *conn) NewStream(
 	ctx context.Context,
 	desc *grpc.StreamDesc,
@@ -462,6 +401,8 @@ func (c *conn) NewStream(
 			trace.Method(method),
 		)
 		wrapping = needWrapping(ctx)
+		cc       *grpc.ClientConn
+		s        grpc.ClientStream
 	)
 
 	defer func() {
@@ -479,13 +420,15 @@ func (c *conn) NewStream(
 		}
 	}()
 
-	var s grpc.ClientStream
-	s, err = c.newStream(
-		ctx,
-		desc,
-		method,
-		opts...,
-	)
+	cc, err = c.take(ctx)
+	if err != nil {
+		return nil, errors.WithStackTrace(err)
+	}
+
+	c.changeStreamUsages(1)
+	defer c.changeStreamUsages(-1)
+
+	s, err = cc.NewStream(ctx, desc, method, opts...)
 
 	if err != nil {
 		if wrapping {
@@ -496,13 +439,13 @@ func (c *conn) NewStream(
 				),
 			)
 		}
-		return s, err
+		return s, errors.WithStackTrace(err)
 	}
 
 	return &grpcClientStream{
-		c:        c,
-		s:        s,
-		wrapping: wrapping,
+		ClientStream: s,
+		c:            c,
+		wrapping:     wrapping,
 		onDone: func(ctx context.Context) {
 			cancel()
 		},