feat: enhance error handling with direct slog.Attr support

This commit updates the error handling functions to allow passing slog.Attr directly to Errorf and Wrap, improving flexibility and usability. It also introduces new helper functions for structured attributes and updates the documentation to reflect these changes. Additionally, comprehensive tests are added to ensure the correct functionality of the new features.

Author: strider2038

MIGRATION.md

@@ -243,16 +243,33 @@ err := errors.Wrap(
 
 ### 3. Direct slog.Attr Usage
 
-Pass `slog.Attr` directly for maximum flexibility:
+v0.5.0 allows passing `slog.Attr` directly without wrapping in `errors.Attr()`:
 
 ```go
+// You can pass slog.Attr directly (NEW!)
 err := errors.Wrap(
     err,
-    errors.Attr(slog.Int64("timestamp", time.Now().Unix())),
-    errors.Attr(slog.Group("metadata",
+    slog.Int64("timestamp", time.Now().Unix()),
+    slog.String("user", "john"),
+    slog.Group("metadata",
         slog.String("version", "v1.2.3"),
         slog.Bool("production", true),
-    )),
+    ),
+)
+
+// Or use helper functions (also works)
+err := errors.Wrap(
+    err,
+    errors.Int64("timestamp", time.Now().Unix()),
+    errors.String("user", "john"),
+)
+
+// Or mix both styles
+err := errors.Wrap(
+    err,
+    errors.SkipCaller(),              // errors.Option
+    slog.String("user", "john"),      // slog.Attr directly
+    errors.Int("id", 123),            // errors.Option
 )
 ```
 

README.md

@@ -75,88 +75,128 @@ func NewNotFoundError() error {
 and returns the string as a value that satisfies error. You can wrap an error using `%w` modifier.
 
 `errors.Errorf()` also records the stack trace at the point it was called. If the wrapped error
-contains a stack trace then a new one will not be added to a chain. Also, you can pass 
-options to set structured attributes or to skip a caller in a stack trace.
-Options must be specified after formatting arguments.
+contains a stack trace then a new one will not be added to a chain.
+
+You can pass options to set structured attributes or to skip a caller in a stack trace.
+Both helper functions like `errors.String()` and `slog.Attr` directly are supported.
+Options/attributes must be specified after formatting arguments.
 
 ```golang
 row := repository.db.QueryRow(ctx, findSQL, id)
 var product Product
 err := row.Scan(&product.ID, &product.Name)
 if err != nil {
-	// Use errors.Errorf to wrap the library error with the message context and
-	// error attributes to be used for structured logging.
+	// Option 1: Use helper functions
 	return nil, errors.Errorf(
 		"%w: %v", errSQLError, err.Error(),
 		errors.String("sql", findSQL),
 		errors.Int("productID", id),
 	)
+	
+	// Option 2: Use slog.Attr directly (more idiomatic)
+	return nil, errors.Errorf(
+		"%w: %v", errSQLError, err.Error(),
+		slog.String("sql", findSQL),
+		slog.Int("productID", id),
+	)
 }
 ```
 
 ### `errors.Wrap()` for wrapping errors with attributes and stack trace
 
 `errors.Wrap()` returns an error annotating err with a stack trace at the point `errors.Wrap()` is called.
 If the wrapped error contains a stack trace then a new one will not be added to a chain.
-If err is nil, Wrap returns nil. Also, you can pass options to set structured attributes or to skip a caller
-in a stack trace.
+If err is nil, Wrap returns nil.
+
+You can pass options to set structured attributes or to skip a caller in a stack trace.
+Both helper functions like `errors.String()` and `slog.Attr` directly are supported.
 
 ```golang
 data, err := service.Handle(ctx, userID, message)
 if err != nil {
-	// Adds a stack trace to the line that was called (if there is no stack trace in the chain already)
-	// and adds attributes for structured logging.
+	// Option 1: Use helper functions
 	return nil, errors.Wrap(
 		err,
 		errors.Int("userID", userID),
 		errors.String("userMessage", message),
 	)
+	
+	// Option 2: Use slog.Attr directly (recommended)
+	return nil, errors.Wrap(
+		err,
+		slog.Int("userID", userID),
+		slog.String("userMessage", message),
+	)
+	
+	// Option 3: Mix both styles
+	return nil, errors.Wrap(
+		err,
+		errors.SkipCaller(),           // Option for stack trace
+		slog.String("userMessage", message),  // slog.Attr for logging
+	)
 }
 ```
 
-### Working with grouped attributes
+### Working with slog attributes
 
-The package supports grouped attributes via `slog.Group`, allowing you to organize related attributes:
+The package has native slog integration - you can pass `slog.Attr` directly to `Wrap()` and `Errorf()`:
 
 ```golang
+// Use slog attributes directly (recommended)
 err := errors.Wrap(
 	dbErr,
-	errors.Group("request",
-		slog.String("method", "POST"),
-		slog.String("path", "/api/users"),
-		slog.Int("status", 500),
-	),
-	errors.Group("database",
-		slog.String("query", "INSERT INTO users..."),
-		slog.Duration("duration", 150*time.Millisecond),
-	),
+	slog.String("table", "users"),
+	slog.Int("id", 123),
+	slog.Duration("query_time", 50*time.Millisecond),
 )
-```
 
-You can use all slog attribute types directly:
+// Or use helper functions (equivalent)
+err := errors.Wrap(
+	dbErr,
+	errors.String("table", "users"),
+	errors.Int("id", 123),
+	errors.Duration("query_time", 50*time.Millisecond),
+)
 
-```golang
+// All slog types are supported
 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{}{
+	slog.Bool("cached", false),
+	slog.Int64("timestamp", time.Now().Unix()),
+	slog.Uint64("bytes_written", uint64(1024*1024*500)),
+	slog.Float64("cpu_usage", 0.85),
+	slog.Any("metadata", map[string]interface{}{
 		"version": "v1.2.3",
 		"region":  "us-west-1",
 	}),
 )
 ```
 
-Or pass `slog.Attr` directly for maximum flexibility:
+### Working with grouped attributes
+
+Organize related attributes using `slog.Group` directly:
 
 ```golang
 err := errors.Wrap(
-	err,
-	errors.Attr(slog.Group("metadata",
-		slog.String("version", "v1.2.3"),
-		slog.Bool("production", true),
-	)),
+	dbErr,
+	slog.Group("request",
+		slog.String("method", "POST"),
+		slog.String("path", "/api/users"),
+		slog.Int("status", 500),
+	),
+	slog.Group("database",
+		slog.String("query", "INSERT INTO users..."),
+		slog.Duration("duration", 150*time.Millisecond),
+	),
+)
+
+// Or use the errors.Group helper
+err := errors.Wrap(
+	dbErr,
+	errors.Group("request",
+		slog.String("method", "POST"),
+		slog.String("path", "/api/users"),
+	),
 )
 ```
 

errors.go

@@ -115,10 +115,17 @@ func Unwrap(err error) error {
 // Errorf formats according to a format specifier and returns the string
 // as a value that satisfies error. You can wrap an error using %w modifier as it
 // does fmt.Errorf function.
+//
 // Errorf also records the stack trace at the point it was called. If the wrapped error
 // contains a stack trace then a new one will not be added to a chain.
-// Also, you can pass an options to set a structured fields or to skip a caller
-// in a stack trace. Options must be specified after formatting arguments.
+//
+// You can pass options to set structured attributes or to skip a caller in a stack trace.
+// Both Option functions and slog.Attr values are accepted.
+// Options/attributes must be specified after formatting arguments:
+//
+//	errors.Errorf("failed: %w", err, errors.String("key", "value"))
+//	errors.Errorf("failed: %w", err, slog.String("key", "value"))
+//	errors.Errorf("failed: %w", err, errors.SkipCaller(), slog.Int("id", 123))
 func Errorf(message string, argsAndOptions ...interface{}) error {
 	args, options := splitArgsAndOptions(argsAndOptions)
 	opts := newOptions(options...)
@@ -138,12 +145,20 @@ func Errorf(message string, argsAndOptions ...interface{}) error {
 // Wrap returns an error annotating err with a stack trace at the point Wrap is called.
 // If the wrapped error contains a stack trace then a new one will not be added to a chain.
 // If err is nil, Wrap returns nil.
-// Also, you can pass an options to set a structured fields or to skip a caller
-// in a stack trace.
-func Wrap(err error, options ...Option) error {
+//
+// You can pass options to set structured attributes or to skip a caller in a stack trace.
+// Both Option functions and slog.Attr values are accepted:
+//
+//	errors.Wrap(err, errors.String("key", "value"))        // Using Option
+//	errors.Wrap(err, slog.String("key", "value"))          // Using slog.Attr directly
+//	errors.Wrap(err, errors.SkipCaller(), slog.Int("id", 123))  // Mixed
+func Wrap(err error, optsOrAttrs ...interface{}) error {
 	if err == nil {
 		return nil
 	}
+
+	options := convertToOptions(optsOrAttrs)
+
 	if isWrapper(err) {
 		if len(options) == 0 {
 			return err
@@ -265,22 +280,45 @@ func (e *stacked) MarshalJSON() ([]byte, error) {
 func splitArgsAndOptions(argsAndOptions []interface{}) ([]interface{}, []Option) {
 	argsCount := len(argsAndOptions)
 	for i := argsCount - 1; i >= 0; i-- {
-		if _, ok := argsAndOptions[i].(Option); ok {
+		if isOptionOrAttr(argsAndOptions[i]) {
 			argsCount--
 		} else {
 			break
 		}
 	}
 
 	args := argsAndOptions[:argsCount]
-	options := make([]Option, 0, len(argsAndOptions)-argsCount)
-	for i := argsCount; i < len(argsAndOptions); i++ {
-		options = append(options, argsAndOptions[i].(Option))
-	}
+	optsOrAttrs := argsAndOptions[argsCount:]
+	options := convertToOptions(optsOrAttrs)
 
 	return args, options
 }
 
+// isOptionOrAttr checks if a value is either an Option or slog.Attr
+func isOptionOrAttr(v interface{}) bool {
+	if _, ok := v.(Option); ok {
+		return true
+	}
+	if _, ok := v.(slog.Attr); ok {
+		return true
+	}
+	return false
+}
+
+// convertToOptions converts a slice of Option and/or slog.Attr to []Option
+func convertToOptions(items []interface{}) []Option {
+	options := make([]Option, 0, len(items))
+	for _, item := range items {
+		switch v := item.(type) {
+		case Option:
+			options = append(options, v)
+		case slog.Attr:
+			options = append(options, Attr(v))
+		}
+	}
+	return options
+}
+
 func getArgErrors(message string, args []interface{}) []error {
 	indices := getErrorIndices(message)
 	errs := make([]error, 0, len(indices))
@@ -361,7 +399,7 @@ func writeAttrs(w io.Writer, attrs []slog.Attr, prefix string) {
 // writeAttr writes a single attribute value to an io.Writer
 func writeAttr(w io.Writer, key string, value slog.Value) {
 	io.WriteString(w, "\n"+key+": ")
-	
+
 	switch value.Kind() {
 	case slog.KindBool:
 		if value.Bool() {