attributes: catch panics during typed nil formatting by fmt.Stringer

Author: searKing

attributes/attributes.go

@@ -27,6 +27,7 @@ package attributes
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 )
 
@@ -121,8 +122,26 @@ func (a *Attributes) String() string {
 	return sb.String()
 }
 
-func str(x any) string {
-	if v, ok := x.(fmt.Stringer); ok {
+func str(x any) (s string) {
+	defer func() {
+		if r := recover(); r != nil {
+			// If it panics with a nil pointer, just say "<nil>". The likeliest causes are a
+			// [fmt.Stringer] that fails to guard against nil or a nil pointer for a
+			// value receiver, and in either case, "<nil>" is a nice result.
+			//
+			// Adapted from the code in fmt/print.go.
+			if v := reflect.ValueOf(x); v.Kind() == reflect.Pointer && v.IsNil() {
+				s = "<nil>"
+				return
+			}
+
+			// The panic was likely not caused by fmt.Stringer.
+			panic(r)
+		}
+	}()
+	if x == nil {
+		return "<nil>"
+	} else if v, ok := x.(fmt.Stringer); ok {
 		return v.String()
 	} else if v, ok := x.(string); ok {
 		return v

attributes/attributes_test.go

@@ -29,6 +29,10 @@ type stringVal struct {
 	s string
 }
 
+func (s stringVal) String() string {
+	return s.s
+}
+
 func (s stringVal) Equal(o any) bool {
 	os, ok := o.(stringVal)
 	return ok && s.s == os.s
@@ -57,6 +61,27 @@ func ExampleAttributes_WithValue() {
 	// Key two: {two}
 }
 
+func ExampleString() {
+	type keyOne struct{}
+	type keyTwo struct{}
+	type keyThree struct{}
+	type keyFour struct{}
+	a1 := attributes.New(keyOne{}, nil)               // untyped nil
+	a2 := attributes.New(keyTwo{}, (*stringVal)(nil)) // typed nil
+	a3 := attributes.New(keyThree{}, 1)
+	a4 := attributes.New(keyFour{}, stringVal{s: "two"})
+	fmt.Println("a1:", a1.String())
+	fmt.Println("a2:", a2.String())
+	fmt.Println("a3:", a3.String())
+	fmt.Println("a4:", a4.String())
+
+	// Output:
+	// a1: {"<%!p(attributes_test.keyOne={})>": "<nil>" }
+	// a2: {"<%!p(attributes_test.keyTwo={})>": "<nil>" }
+	// a3: {"<%!p(attributes_test.keyThree={})>": "<%!p(int=1)>" }
+	// a4: {"<%!p(attributes_test.keyFour={})>": "two" }
+}
+
 // Test that two attributes with the same content are Equal.
 func TestEqual(t *testing.T) {
 	type keyOne struct{}