feat: add complete slog type coverage and deprecate Value function

This commit introduces dedicated functions for all slog attribute types, including Int64, Uint64, Float64, and Any, enhancing the flexibility of error handling. The Value function is deprecated in favor of Any for better consistency. Additionally, tests are added to ensure the new attribute options work as expected.

Author: strider2038

MIGRATION.md

@@ -173,7 +173,34 @@ func TestMyError(t *testing.T) {
 
 ## New Features
 
-### 1. Grouped Attributes
+### 1. Complete slog Type Coverage
+
+All slog attribute types are now supported with dedicated functions:
+
+```go
+// New in v0.5.0
+errors.Int64(key string, value int64)
+errors.Uint64(key string, value uint64)
+errors.Float64(key string, value float64)
+errors.Any(key string, value interface{})  // Replaces Value
+
+// Deprecated
+errors.Value(key string, value interface{}) // Use Any instead
+```
+
+Example:
+
+```go
+err := errors.Wrap(
+    dbErr,
+    errors.Int64("timestamp", time.Now().Unix()),
+    errors.Uint64("bytes_processed", uint64(1024*1024)),
+    errors.Float64("cpu_usage", 0.75),
+    errors.Any("metadata", map[string]string{"region": "us-west"}),
+)
+```
+
+### 2. Grouped Attributes
 
 Group related attributes together for better structure:
 
@@ -214,7 +241,7 @@ err := errors.Wrap(
 // query.duration: 150ms
 ```
 
-### 2. Direct slog.Attr Usage
+### 3. Direct slog.Attr Usage
 
 Pass `slog.Attr` directly for maximum flexibility:
 
@@ -229,7 +256,7 @@ err := errors.Wrap(
 )
 ```
 
-### 3. Multiple Attributes at Once
+### 4. Multiple Attributes at Once
 
 ```go
 commonAttrs := []slog.Attr{
@@ -240,7 +267,7 @@ commonAttrs := []slog.Attr{
 err := errors.Wrap(err, errors.WithAttrs(commonAttrs...))
 ```
 
-### 4. slog.LogValuer Implementation
+### 5. slog.LogValuer Implementation
 
 Errors automatically work with slog:
 

README.md

@@ -133,12 +133,26 @@ err := errors.Wrap(
 )
 ```
 
-You can also use `errors.Attr()` to pass `slog.Attr` directly:
+You can use all slog attribute types directly:
+
+```golang
+err := errors.Wrap(
+	err,
+	errors.Int64("timestamp", time.Now().Unix()),
+	errors.Uint64("bytes_written", uint64(1024*1024*500)),
+	errors.Float64("cpu_usage", 0.85),
+	errors.Any("metadata", map[string]interface{}{
+		"version": "v1.2.3",
+		"region":  "us-west-1",
+	}),
+)
+```
+
+Or pass `slog.Attr` directly for maximum flexibility:
 
 ```golang
 err := errors.Wrap(
 	err,
-	errors.Attr(slog.Int64("timestamp", time.Now().Unix())),
 	errors.Attr(slog.Group("metadata",
 		slog.String("version", "v1.2.3"),
 		slog.Bool("production", true),
@@ -338,25 +352,34 @@ attrs := errors.Attrs(wrapped)
 
 ## Available attribute options
 
-The package provides convenience functions for creating attributes:
+The package provides convenience functions for creating attributes that correspond to all slog types:
 
 ```golang
+// Basic types
 errors.Bool(key string, value bool)
-errors.Int(key string, value int)
-errors.Uint(key string, value uint)
-errors.Float(key string, value float64)
+errors.Int(key string, value int)               // Converted to int64
+errors.Int64(key string, value int64)
+errors.Uint(key string, value uint)             // Uses slog.Any
+errors.Uint64(key string, value uint64)
+errors.Float(key string, value float64)         // Alias for Float64
+errors.Float64(key string, value float64)
 errors.String(key string, value string)
-errors.Stringer(key string, value fmt.Stringer)
-errors.Strings(key string, values []string)
-errors.Value(key string, value interface{})
+
+// Complex types
+errors.Stringer(key string, value fmt.Stringer) // Converted to string
+errors.Strings(key string, values []string)     // Uses slog.Any
+errors.Any(key string, value interface{})       // For any type
 errors.Time(key string, value time.Time)
 errors.Duration(key string, value time.Duration)
-errors.JSON(key string, value json.RawMessage)
+errors.JSON(key string, value json.RawMessage)  // Uses slog.Any
+
+// slog-specific options
+errors.Attr(attr slog.Attr)                     // Add any slog.Attr directly
+errors.WithAttrs(attrs ...slog.Attr)            // Add multiple slog.Attr values
+errors.Group(key string, attrs ...slog.Attr)    // Create a grouped attribute
 
-// New slog-specific options
-errors.Attr(attr slog.Attr)                    // Add any slog.Attr directly
-errors.WithAttrs(attrs ...slog.Attr)           // Add multiple slog.Attr values
-errors.Group(key string, attrs ...slog.Attr)   // Create a grouped attribute
+// Deprecated
+errors.Value(key string, value interface{})     // Use Any instead
 ```
 
 ## Contributing

options.go

@@ -50,12 +50,20 @@ func Bool(key string, value bool) Option {
 }
 
 // Int returns an Option that adds an integer attribute to the error.
+// The value is converted to int64 for slog compatibility.
 func Int(key string, value int) Option {
 	return func(options *Options) {
 		options.addAttr(slog.Int(key, value))
 	}
 }
 
+// Int64 returns an Option that adds an int64 attribute to the error.
+func Int64(key string, value int64) Option {
+	return func(options *Options) {
+		options.addAttr(slog.Int64(key, value))
+	}
+}
+
 // Uint returns an Option that adds an unsigned integer attribute to the error.
 // Note: slog doesn't have a native Uint type, so this uses Any().
 func Uint(key string, value uint) Option {
@@ -64,13 +72,26 @@ func Uint(key string, value uint) Option {
 	}
 }
 
-// Float returns an Option that adds a float64 attribute to the error.
-func Float(key string, value float64) Option {
+// Uint64 returns an Option that adds a uint64 attribute to the error.
+func Uint64(key string, value uint64) Option {
+	return func(options *Options) {
+		options.addAttr(slog.Uint64(key, value))
+	}
+}
+
+// Float64 returns an Option that adds a float64 attribute to the error.
+func Float64(key string, value float64) Option {
 	return func(options *Options) {
 		options.addAttr(slog.Float64(key, value))
 	}
 }
 
+// Float returns an Option that adds a float64 attribute to the error.
+// Alias for Float64 for backward compatibility.
+func Float(key string, value float64) Option {
+	return Float64(key, value)
+}
+
 // String returns an Option that adds a string attribute to the error.
 func String(key string, value string) Option {
 	return func(options *Options) {
@@ -92,13 +113,29 @@ func Strings(key string, values []string) Option {
 	}
 }
 
-// Value returns an Option that adds an arbitrary value attribute to the error.
-func Value(key string, value interface{}) Option {
+// Any returns an Option that adds an arbitrary value attribute to the error.
+// This is the most flexible option and can handle any type that slog.Any supports.
+//
+// Example:
+//
+//	err := errors.Wrap(err,
+//	    errors.Any("metadata", map[string]string{"version": "v1.0"}),
+//	    errors.Any("items", []int{1, 2, 3}),
+//	)
+func Any(key string, value interface{}) Option {
 	return func(options *Options) {
 		options.addAttr(slog.Any(key, value))
 	}
 }
 
+// Value returns an Option that adds an arbitrary value attribute to the error.
+//
+// Deprecated: Use Any instead. Value is kept for backward compatibility
+// but will be removed in a future version.
+func Value(key string, value interface{}) Option {
+	return Any(key, value)
+}
+
 // Time returns an Option that adds a time.Time attribute to the error.
 func Time(key string, value time.Time) Option {
 	return func(options *Options) {

options_test.go

@@ -0,0 +1,93 @@
+package errors_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/muonsoft/errors"
+)
+
+func TestNewAttributeOptions(t *testing.T) {
+	tests := []struct {
+		name     string
+		err      error
+		expected interface{}
+	}{
+		{
+			name:     "Int64",
+			err:      errors.Wrap(errors.New("test"), errors.Int64("key", 9223372036854775807)),
+			expected: int64(9223372036854775807),
+		},
+		{
+			name:     "Uint64",
+			err:      errors.Wrap(errors.New("test"), errors.Uint64("key", 18446744073709551615)),
+			expected: uint64(18446744073709551615),
+		},
+		{
+			name:     "Float64",
+			err:      errors.Wrap(errors.New("test"), errors.Float64("key", 3.14159)),
+			expected: 3.14159,
+		},
+		{
+			name:     "Any with struct",
+			err:      errors.Wrap(errors.New("test"), errors.Any("key", struct{ Name string }{"test"})),
+			expected: struct{ Name string }{"test"},
+		},
+		{
+			name:     "Any with map",
+			err:      errors.Wrap(errors.New("test"), errors.Any("key", map[string]int{"count": 42})),
+			expected: map[string]int{"count": 42},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			attrs := errors.Attrs(test.err)
+			if len(attrs) == 0 {
+				t.Fatalf("expected %#v to have attributes", test.err)
+			}
+
+			var found bool
+			var value interface{}
+			for _, attr := range attrs {
+				if attr.Key == "key" {
+					value = attr.Value.Any()
+					found = true
+					break
+				}
+			}
+
+			if !found {
+				t.Fatalf("expected %#v to have attribute with key 'key'", test.err)
+			}
+
+			if !reflect.DeepEqual(value, test.expected) {
+				t.Errorf("want value %v (%T), got %v (%T)", test.expected, test.expected, value, value)
+			}
+		})
+	}
+}
+
+func TestValueDeprecated(t *testing.T) {
+	// Test that Value still works but behaves the same as Any
+	errWithValue := errors.Wrap(errors.New("test"), errors.Value("key", "test-value"))
+	errWithAny := errors.Wrap(errors.New("test"), errors.Any("key", "test-value"))
+
+	attrsValue := errors.Attrs(errWithValue)
+	attrsAny := errors.Attrs(errWithAny)
+
+	if len(attrsValue) != 1 || len(attrsAny) != 1 {
+		t.Fatalf("expected both errors to have exactly 1 attribute")
+	}
+
+	valueAttr := attrsValue[0]
+	anyAttr := attrsAny[0]
+
+	if valueAttr.Key != anyAttr.Key {
+		t.Errorf("expected same key, got Value=%s, Any=%s", valueAttr.Key, anyAttr.Key)
+	}
+
+	if valueAttr.Value.Any() != anyAttr.Value.Any() {
+		t.Errorf("expected same value, got Value=%v, Any=%v", valueAttr.Value.Any(), anyAttr.Value.Any())
+	}
+}