migrated from logrus to zerolog, improved error formatting, fixed concurrent map write, fixed crash on rapid page refresh for idle containers, fixed infinite recursion on gotfiy error, fixed websocket connection problem when using idlewatcher

internal/error/builder.go

@@ -1,104 +1,104 @@
 package error
 
 import (
-	"errors"
 	"fmt"
 	"sync"
 )
 
 type Builder struct {
-	*builder
-}
-
-type builder struct {
-	message string
-	errors  []Error
+	about string
+	errs  []error
 	sync.Mutex
 }
 
-func NewBuilder(format string, args ...any) Builder {
-	if len(args) > 0 {
-		return Builder{&builder{message: fmt.Sprintf(format, args...)}}
+func NewBuilder(about string) *Builder {
+	return &Builder{about: about}
+}
+
+func (b *Builder) About() string {
+	if !b.HasError() {
+		return ""
 	}
-	return Builder{&builder{message: format}}
+	return b.about
+}
+
+//go:inline
+func (b *Builder) HasError() bool {
+	return len(b.errs) > 0
+}
+
+func (b *Builder) Error() Error {
+	if !b.HasError() {
+		return nil
+	}
+	if len(b.errs) == 1 {
+		return From(b.errs[0])
+	}
+	return &nestedError{Err: New(b.about), Extras: b.errs}
+}
+
+func (b *Builder) String() string {
+	if !b.HasError() {
+		return ""
+	}
+	return (&nestedError{Err: New(b.about), Extras: b.errs}).Error()
 }
 
 // Add adds an error to the Builder.
 //
 // adding nil is no-op,
-//
-// flatten is a boolean flag to flatten the NestedError.
-func (b Builder) Add(err Error, flatten ...bool) {
-	if err != nil {
-		b.Lock()
-		if len(flatten) > 0 && flatten[0] {
-			for _, e := range err.extras {
-				b.errors = append(b.errors, &e)
-			}
+func (b *Builder) Add(err error) *Builder {
+	if err == nil {
+		return b
+	}
+
+	b.Lock()
+	defer b.Unlock()
+
+	switch err := err.(type) {
+	case *baseError:
+		b.errs = append(b.errs, err.Err)
+	case *nestedError:
+		if err.Err == nil {
+			b.errs = append(b.errs, err.Extras...)
 		} else {
-			b.errors = append(b.errors, err)
+			b.errs = append(b.errs, err)
 		}
-		b.Unlock()
-	}
-}
-
-func (b Builder) AddE(err error) {
-	b.Add(From(err))
-}
-
-func (b Builder) Addf(format string, args ...any) {
-	if len(args) > 0 {
-		b.Add(errorf(format, args...))
-	} else {
-		b.AddE(errors.New(format))
-	}
-}
-
-func (b Builder) AddRange(errs ...Error) {
-	b.Lock()
-	defer b.Unlock()
-	for _, err := range errs {
-		b.errors = append(b.errors, err)
-	}
-}
-
-func (b Builder) AddRangeE(errs ...error) {
-	b.Lock()
-	defer b.Unlock()
-	for _, err := range errs {
-		b.errors = append(b.errors, From(err))
-	}
-}
-
-// Build builds a NestedError based on the errors collected in the Builder.
-//
-// If there are no errors in the Builder, it returns a Nil() NestedError.
-// Otherwise, it returns a NestedError with the message and the errors collected.
-//
-// Returns:
-//   - NestedError: the built NestedError.
-func (b Builder) Build() Error {
-	if len(b.errors) == 0 {
-		return nil
-	}
-	return Join(b.message, b.errors...)
-}
-
-func (b Builder) To(ptr *Error) {
-	switch {
-	case ptr == nil:
-		return
-	case *ptr == nil:
-		*ptr = b.Build()
 	default:
-		(*ptr).extras = append((*ptr).extras, *b.Build())
+		b.errs = append(b.errs, err)
 	}
+
+	return b
 }
 
-func (b Builder) String() string {
-	return b.Build().String()
+func (b *Builder) Adds(err string) *Builder {
+	b.Lock()
+	defer b.Unlock()
+	b.errs = append(b.errs, newError(err))
+	return b
 }
 
-func (b Builder) HasError() bool {
-	return len(b.errors) > 0
+func (b *Builder) Addf(format string, args ...any) *Builder {
+	if len(args) > 0 {
+		b.Lock()
+		defer b.Unlock()
+		b.errs = append(b.errs, fmt.Errorf(format, args...))
+	} else {
+		b.Adds(format)
+	}
+
+	return b
+}
+
+func (b *Builder) AddRange(errs ...error) *Builder {
+	b.Lock()
+	defer b.Unlock()
+
+	for _, err := range errs {
+		if err != nil {
+			b.errs = append(b.errs, err)
+		}
+	}
+
+	return b
 }