Add "Printable" properties

Add properties that will be included into error message.

Author: funny-falcon

error.go

@@ -16,9 +16,11 @@ type Error struct {
 	stackTrace *stackTrace
 	// properties are used both for public properties inherited through "transparent" wrapping
 	// and for some optional per-instance information like "underlying errors"
-	properties    *propertyMap
-	transparent   bool
-	hasUnderlying bool
+	properties *propertyMap
+
+	transparent            bool
+	hasUnderlying          bool
+	printablePropertyCount uint8
 }
 
 var _ fmt.Formatter = (*Error)(nil)
@@ -31,6 +33,9 @@ var _ fmt.Formatter = (*Error)(nil)
 func (e *Error) WithProperty(key Property, value interface{}) *Error {
 	errorCopy := *e
 	errorCopy.properties = errorCopy.properties.with(key, value)
+	if key.printable && errorCopy.printablePropertyCount < 255 {
+		errorCopy.printablePropertyCount++
+	}
 	return &errorCopy
 }
 
@@ -205,6 +210,25 @@ func (e *Error) underlyingInfo() string {
 	return fmt.Sprintf("(hidden: %s)", joinStringsIfNonEmpty(", ", infos...))
 }
 
+func (e *Error) messageFromProperties() string {
+	if e.printablePropertyCount == 0 {
+		return ""
+	}
+	uniq := make(map[Property]struct{}, e.printablePropertyCount)
+	strs := make([]string, 0, e.printablePropertyCount)
+	for m := e.properties; m != nil; m = m.next {
+		if !m.p.printable {
+			continue
+		}
+		if _, ok := uniq[m.p]; ok {
+			continue
+		}
+		uniq[m.p] = struct{}{}
+		strs = append(strs, fmt.Sprintf("%s: %v", m.p.label, m.value))
+	}
+	return "{" + strings.Join(strs, ", ") + "}"
+}
+
 func (e *Error) underlying() []error {
 	if !e.hasUnderlying {
 		return nil
@@ -216,21 +240,35 @@ func (e *Error) underlying() []error {
 }
 
 func (e *Error) messageText() string {
-	if e.Cause() == nil {
-		return e.message
+	message := joinStringsIfNonEmpty(" ", e.message, e.messageFromProperties())
+	if cause := e.Cause(); cause != nil {
+		return joinStringsIfNonEmpty(", cause: ", message, cause.Error())
 	}
-
-	underlyingFullMessage := e.Cause().Error()
-	return joinStringsIfNonEmpty(", cause: ", e.message, underlyingFullMessage)
+	return message
 }
 
 func joinStringsIfNonEmpty(delimiter string, parts ...string) string {
-	filteredParts := make([]string, 0, len(parts))
-	for _, part := range parts {
-		if len(part) > 0 {
-			filteredParts = append(filteredParts, part)
+	switch len(parts) {
+	case 0:
+		return ""
+	case 1:
+		return parts[0]
+	case 2:
+		if len(parts[0]) == 0 {
+			return parts[1]
+		} else if len(parts[1]) == 0 {
+			return parts[0]
+		} else {
+			return parts[0] + delimiter + parts[1]
+		}
+	default:
+		filteredParts := make([]string, 0, len(parts))
+		for _, part := range parts {
+			if len(part) > 0 {
+				filteredParts = append(filteredParts, part)
+			}
 		}
-	}
 
-	return strings.Join(filteredParts, delimiter)
+		return strings.Join(filteredParts, delimiter)
+	}
 }

property.go

@@ -12,13 +12,21 @@ type Property struct {
 }
 
 type property struct {
-	label string
+	label     string
+	printable bool
 }
 
 // RegisterProperty registers a new property key.
 // It is used both to add a dynamic property to an error instance, and to extract property value back from error.
 func RegisterProperty(label string) Property {
-	return newProperty(label)
+	return newProperty(label, false)
+}
+
+// RegisterPrintableProperty registers a new property key for informational value.
+// It is used both to add a dynamic property to an error instance, and to extract property value back from error.
+// Informational property will be included in Error() message.
+func RegisterPrintableProperty(label string) Property {
+	return newProperty(label, true)
 }
 
 // PropertyContext is a context property, value is expected to be of context.Context type.
@@ -73,10 +81,11 @@ var (
 	propertyUnderlying = RegisterProperty("underlying")
 )
 
-func newProperty(label string) Property {
+func newProperty(label string, printable bool) Property {
 	p := Property{
 		&property{
-			label: label,
+			label:     label,
+			printable: printable,
 		},
 	}
 	return p

property_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -33,6 +34,8 @@ func TestNoProperty(t *testing.T) {
 
 var testProperty0 = RegisterProperty("test0")
 var testProperty1 = RegisterProperty("test1")
+var testInfoProperty2 = RegisterPrintableProperty("prop2")
+var testInfoProperty3 = RegisterPrintableProperty("prop3")
 
 func TestProperty(t *testing.T) {
 	t.Run("Different", func(t *testing.T) {
@@ -109,6 +112,48 @@ func TestProperty(t *testing.T) {
 	})
 }
 
+func TestPrintableProperty(t *testing.T) {
+	err := testTypeSilent.New("test").WithProperty(testInfoProperty2, "hello world")
+	t.Run("Simple", func(t *testing.T) {
+		assert.Equal(t, "foo.bar.silent: test {prop2: hello world}", err.Error())
+	})
+
+	t.Run("Overwrite", func(t *testing.T) {
+		err := err.WithProperty(testInfoProperty2, "cruel world")
+		assert.Equal(t, "foo.bar.silent: test {prop2: cruel world}", err.Error())
+	})
+
+	t.Run("AddMore", func(t *testing.T) {
+		err := err.WithProperty(testInfoProperty3, struct{ a int }{1})
+		assert.Equal(t, "foo.bar.silent: test {prop3: {1}, prop2: hello world}", err.Error())
+	})
+
+	t.Run("NonPrintableIsInvisible", func(t *testing.T) {
+		err := err.WithProperty(testProperty0, "nah")
+		assert.Equal(t, "foo.bar.silent: test {prop2: hello world}", err.Error())
+	})
+
+	t.Run("WithUnderlying", func(t *testing.T) {
+		err := err.WithUnderlyingErrors(testTypeSilent.New("underlying"))
+		assert.Equal(t, "foo.bar.silent: test {prop2: hello world} (hidden: foo.bar.silent: underlying)", err.Error())
+	})
+
+	err2 := Decorate(err, "oops")
+	t.Run("Decorate", func(t *testing.T) {
+		assert.Equal(t, "oops, cause: foo.bar.silent: test {prop2: hello world}", err2.Error())
+	})
+
+	t.Run("DecorateAndAddMore", func(t *testing.T) {
+		err := err2.WithProperty(testInfoProperty3, struct{ a int }{1})
+		assert.Equal(t, "oops {prop3: {1}}, cause: foo.bar.silent: test {prop2: hello world}", err.Error())
+	})
+
+	t.Run("DecorateAndAddSame", func(t *testing.T) {
+		err := err2.WithProperty(testInfoProperty2, "cruel world")
+		assert.Equal(t, "oops {prop2: cruel world}, cause: foo.bar.silent: test {prop2: hello world}", err.Error())
+	})
+}
+
 func BenchmarkAllocProperty(b *testing.B) {
 	const N = 9
 	var properties = []Property{}