How Can I Effectively Handle Error Propagation in Multi-Layer Go Abstractions?

Error Propagation in Multi-Layer Abstractions

In Go, error handling across multiple levels of abstraction can become a challenge due to the necessity of continually passing the error upwards. This often leads to duplicate logging messages or the loss of contextual information.

Recommended Solution: Error Annotation

The preferred method of error handling is to annotate errors as they are passed through different abstraction levels. This allows for preserving the context of the original error while adding additional information at each level.

Using a library like "github.com/pkg/errors," the error handling can be implemented as follows:

// Wraps the original error with additional context.
func (o *ObjectOne) CheckValue() error {
    if o.someValue == 0 {
        return errors.New("Object1 illegal state: value is 0")
    }
    return nil
}

// Annotates the original error with context.
func (oT *ObjectTwoHigherLevel) CheckObjectOneIsReady() error {
    if err := oT.objectOne.CheckValue(); err != nil {
        return errors.Wrap(err, "Object2 illegal state: Object1 is invalid")
    }
    return nil
}

// Preserves the annotated error stack.
func (oTh *ObjectThreeHiggerLevel) CheckObjectTwoIsReady() error {
    if err := oTh.ObjectTwoHigherLevel.CheckObjectOneIsReady(); err != nil {
        return errors.Wrap(err, "Object3 illegal state: Object2 is invalid")
    }
    return nil
}

Usage:

o3 := &ObjectThreeHiggerLevel{}
if err := o3.CheckObjectTwoIsReady(); err != nil {
    fmt.Println(err)
}

Output:

Object3 illegal state: Object2 illegal state: Object1 illegal state: value is 0

This approach provides a clean and informative error handling mechanism that avoids duplicate logging and preserves contextual information.

Alternative: Error Extension

For simplicity, an alternative approach is to extend the original error with additional context using fmt.Errorf():

func (o *ObjectOne) CheckValue() error {
    if o.someValue == 0 {
        return fmt.Errorf("Object1 illegal state: value is %d", o.someValue)
    }
    return nil
}

Usage:

o3 := &ObjectThreeHiggerLevel{}
if err := o3.CheckObjectTwoIsReady(); err != nil {
    fmt.Println(err)
}

Output:

Object3 illegal state: Object2 illegal state: Object1 illegal state: value is 0

This approach is less versatile than error annotation but is simpler to implement.

The above is the detailed content of How Can I Effectively Handle Error Propagation in Multi-Layer Go Abstractions?. For more information, please follow other related articles on the PHP Chinese website!