Expose OriginalFailure and use retryableOverride bool in serialization

Author: bergundy

nexus/api.go

@@ -71,7 +71,7 @@ type OperationError struct {
 	// The underlying cause for this error.
 	Cause error
 	// Set if this error is constructed from a failure object.
-	originalFailure *Failure
+	OriginalFailure *Failure
 }
 
 // UnsuccessfulOperationError represents "failed" and "canceled" operation results.
@@ -229,7 +229,7 @@ type HandlerError struct {
 	// RetryBehavior of this error. If not specified, retry behavior is determined from the error type.
 	RetryBehavior HandlerErrorRetryBehavior
 	// Set if this error is constructed from a failure object.
-	originalFailure *Failure
+	OriginalFailure *Failure
 }
 
 // HandlerErrorf creates a [HandlerError] with the given type, using [fmt.Sprintf] to construct the message.
@@ -266,14 +266,16 @@ func (e *HandlerError) Retryable() bool {
 	}
 }
 
-func (e *HandlerError) retryBehaviorAsString() string {
+func (e *HandlerError) retryBehaviorAsOptionalBool() *bool {
 	switch e.RetryBehavior {
 	case HandlerErrorRetryBehaviorRetryable:
-		return "true"
+		ret := true
+		return &ret
 	case HandlerErrorRetryBehaviorNonRetryable:
-		return "false"
+		ret := false
+		return &ret
 	}
-	return ""
+	return nil
 }
 
 // Error implements the error interface.

nexus/failure.go

@@ -58,18 +58,18 @@ type FailureConverter interface {
 type knownErrorFailureConverter struct{}
 
 type serializedHandlerError struct {
-	Type      string `json:"type,omitempty"`
-	Retryable string `json:"retryable,omitempty"`
+	Type              string `json:"type,omitempty"`
+	RetryableOverride *bool  `json:"retryableOverride,omitempty"`
 }
 
 func (e serializedHandlerError) RetryBehavior() HandlerErrorRetryBehavior {
-	switch e.Retryable {
-	case "true":
+	if e.RetryableOverride == nil {
+		return HandlerErrorRetryBehaviorUnspecified
+	}
+	if *e.RetryableOverride {
 		return HandlerErrorRetryBehaviorRetryable
-	case "false":
+	} else {
 		return HandlerErrorRetryBehaviorNonRetryable
-	default:
-		return HandlerErrorRetryBehaviorUnspecified
 	}
 }
 
@@ -96,16 +96,16 @@ func (e knownErrorFailureConverter) ErrorToFailure(err error) (Failure, error) {
 		}
 		return f, nil
 	case *HandlerError:
-		if typedErr.originalFailure != nil {
-			return *typedErr.originalFailure, nil
+		if typedErr.OriginalFailure != nil {
+			return *typedErr.OriginalFailure, nil
 		}
 		// Temporary workaround for compatibility with old SDKs that don't support handler error messages.
 		if typedErr.Message == "" && typedErr.Cause != nil {
 			return e.ErrorToFailure(typedErr.Cause)
 		}
 		data := serializedHandlerError{
-			Type:      string(typedErr.Type),
-			Retryable: typedErr.retryBehaviorAsString(),
+			Type:              string(typedErr.Type),
+			RetryableOverride: typedErr.retryBehaviorAsOptionalBool(),
 		}
 		var details []byte
 		details, err := json.Marshal(data)
@@ -131,8 +131,8 @@ func (e knownErrorFailureConverter) ErrorToFailure(err error) (Failure, error) {
 
 		return f, nil
 	case *OperationError:
-		if typedErr.originalFailure != nil {
-			return *typedErr.originalFailure, nil
+		if typedErr.OriginalFailure != nil {
+			return *typedErr.OriginalFailure, nil
 		}
 		// Temporary workaround for compatibility with old SDKs that don't support operation error messages.
 		if typedErr.Message == "" && typedErr.Cause != nil {
@@ -184,7 +184,7 @@ func (e knownErrorFailureConverter) FailureToError(f Failure) (error, error) {
 				StackTrace:      f.StackTrace,
 				Type:            HandlerErrorType(se.Type),
 				RetryBehavior:   se.RetryBehavior(),
-				originalFailure: &f,
+				OriginalFailure: &f,
 			}
 			if f.Cause != nil {
 				he.Cause, err = e.FailureToError(*f.Cause)
@@ -203,7 +203,7 @@ func (e knownErrorFailureConverter) FailureToError(f Failure) (error, error) {
 				Message:         f.Message,
 				StackTrace:      f.StackTrace,
 				State:           OperationState(se.State),
-				originalFailure: &f,
+				OriginalFailure: &f,
 			}
 			if f.Cause != nil {
 				oe.Cause, err = e.FailureToError(*f.Cause)

nexus/failure_test.go

@@ -52,7 +52,7 @@ func TestFailureConverter_HandlerError(t *testing.T) {
 	failure, err := defaultFailureConverter.ErrorToFailure(he)
 	require.NoError(t, err)
 	// Verify that the original failure is retained.
-	he.originalFailure = &failure
+	he.OriginalFailure = &failure
 	actual, err := defaultFailureConverter.FailureToError(failure)
 	require.NoError(t, err)
 	require.Equal(t, he, actual)
@@ -68,6 +68,26 @@ func TestFailureConverter_HandlerError(t *testing.T) {
 	require.Equal(t, he, actual)
 }
 
+func TestFailureConverter_HandlerErrorRetryBehavior(t *testing.T) {
+	he := HandlerErrorf(HandlerErrorTypeBadRequest, "foo")
+	he.StackTrace = "stack"
+	he.RetryBehavior = HandlerErrorRetryBehaviorRetryable
+	failure, err := defaultFailureConverter.ErrorToFailure(he)
+	require.NoError(t, err)
+	// Verify that the original failure is retained.
+	he.OriginalFailure = &failure
+	actual, err := defaultFailureConverter.FailureToError(failure)
+	require.NoError(t, err)
+	require.Equal(t, he, actual)
+
+	// Serialize again and verify the original failure is used.
+	failure, err = defaultFailureConverter.ErrorToFailure(he)
+	require.NoError(t, err)
+	actual, err = defaultFailureConverter.FailureToError(failure)
+	require.NoError(t, err)
+	require.Equal(t, he, actual)
+}
+
 func TestFailureConverter_OperationError(t *testing.T) {
 	cause := &FailureError{Failure: Failure{Message: "cause"}}
 	oe := NewOperationCanceledError("foo")
@@ -76,7 +96,7 @@ func TestFailureConverter_OperationError(t *testing.T) {
 	failure, err := defaultFailureConverter.ErrorToFailure(oe)
 	require.NoError(t, err)
 	// Verify that the original failure is retained.
-	oe.originalFailure = &failure
+	oe.OriginalFailure = &failure
 	actual, err := defaultFailureConverter.FailureToError(failure)
 	require.NoError(t, err)
 	require.Equal(t, oe, actual)

nexus/server_test.go

@@ -46,7 +46,7 @@ func TestWriteFailure_HandlerError(t *testing.T) {
 	actual, err := defaultFailureConverter.FailureToError(failure)
 	require.NoError(t, err)
 	// Assign the original failure object before performing the comparison.
-	he.originalFailure = &failure
+	he.OriginalFailure = &failure
 	require.Equal(t, he, actual)
 }
 
@@ -69,6 +69,6 @@ func TestWriteFailure_OperationError(t *testing.T) {
 	actual, err := defaultFailureConverter.FailureToError(failure)
 	require.NoError(t, err)
 	// Assign the original failure object before performing the comparison.
-	oe.originalFailure = &failure
+	oe.OriginalFailure = &failure
 	require.Equal(t, oe, actual)
 }