refactor: integrate native log/slog support and remove custom field system

This commit introduces breaking changes by replacing the custom field system with Go's native log/slog attributes. Key updates include the removal of the FieldLogger interface and related field types, the addition of slog.Attr support, and the introduction of new logging functions. The migration guide is provided for transitioning from v0.4.1 to v0.5.0.

Author: strider2038

MIGRATION.md

@@ -9,9 +9,13 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/fe1720426006f3af30b0/maintainability)](https://codeclimate.com/github/muonsoft/errors/maintainability)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)
 
-Errors package for structured logging. Adds stack trace without a pain
+Errors package for structured logging with native `log/slog` integration. Adds stack trace without a pain
 (no confuse with `Wrap`/`WithMessage` methods).
 
+> **⚠️ Breaking Changes in v0.5.0**  
+> Version 0.5.0 replaces the custom field system with native `log/slog` integration.  
+> If you're migrating from v0.4.1, please read the [Migration Guide](MIGRATION.md).
+
 ## Key features
 
 This package is based on well known [github.com/pkg/errors](https://github.com/pkg/errors).
@@ -22,13 +26,17 @@ Key differences and features:
 * minimalistic API: few methods to wrap an error: `errors.Errorf()`, `errors.Wrap()`;
 * adds stack trace idempotently (only once in a chain);
 * `errors.As()` method is based on typed parameters (aka generics);
-* options to skip caller in a stack trace and to add error fields for structured logging;
-* error fields are made for the statically typed logger interface;
+* options to skip caller in a stack trace and to add error attributes for structured logging;
+* **native integration with Go's `log/slog`** - error attributes use `slog.Attr`;
+* **supports grouped attributes** via `slog.Group`;
+* implements `slog.LogValuer` for seamless slog integration;
 * package errors can be easily marshaled into JSON with all fields in a chain.
 
 ## Additional features
 
 * `errors.IsOfType[T any](err error)` to test for error types.
+* `errors.Attrs(err error) []slog.Attr` to extract all attributes from error chain.
+* `errors.Log(ctx, logger, level, err)` convenience function for logging with slog.
 
 ## Installation
 
@@ -38,6 +46,10 @@ Run the following command to install the package
 go get -u github.com/muonsoft/errors
 ```
 
+Requires Go 1.21+ for `log/slog` support.
+
+**Migrating from v0.4.1?** See the [Migration Guide](MIGRATION.md) for detailed instructions.
+
 ## How to use
 
 ### `errors.New()` for package-level errors
@@ -57,14 +69,14 @@ func NewNotFoundError() error {
 }
 ```
 
-### `errors.Errorf()` for wrapping errors with formatted message, fields and stack trace
+### `errors.Errorf()` for wrapping errors with formatted message, attributes and stack trace
 
 `errors.Errorf()` is an equivalent to standard `fmt.Errorf()`. It formats according to a format specifier 
 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 an 
-options to set a structured fields or to skip a caller in a stack trace.
+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.
 
 ```golang
@@ -73,7 +85,7 @@ 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 fields to be used for structured logging.
+	// error attributes to be used for structured logging.
 	return nil, errors.Errorf(
 		"%w: %v", errSQLError, err.Error(),
 		errors.String("sql", findSQL),
@@ -82,18 +94,18 @@ if err != nil {
 }
 ```
 
-### `errors.Wrap()` for wrapping errors with fields and stack trace
+### `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 an options to set a structured fields or to skip a caller
+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.
 
 ```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 fields for structured logging.
+	// and adds attributes for structured logging.
 	return nil, errors.Wrap(
 		err,
 		errors.Int("userID", userID),
@@ -102,9 +114,42 @@ if err != nil {
 }
 ```
 
+### Working with grouped attributes
+
+The package supports grouped attributes via `slog.Group`, allowing you to organize related attributes:
+
+```golang
+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),
+	),
+)
+```
+
+You can also use `errors.Attr()` to pass `slog.Attr` directly:
+
+```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),
+	)),
+)
+```
+
 ### Printing error with stack trace
 
-You can use formatting with `%+v` modifier to print errors with message, fields for logging and a stack trace.
+You can use formatting with `%+v` modifier to print errors with message, attributes and stack trace.
+Grouped attributes are displayed using dot notation.
 
 Example
 
@@ -117,7 +162,10 @@ func main() {
 	)
 	err = errors.Errorf(
 		"find product: %w", err,
-		errors.String("requestID", "24874020-cab7-4ef3-bac5-76858832f8b0"),
+		errors.Group("request",
+			slog.String("id", "24874020-cab7-4ef3-bac5-76858832f8b0"),
+			slog.String("method", "GET"),
+		),
 	)
 	fmt.Printf("%+v", err)
 }
@@ -127,7 +175,8 @@ Output
 
 ```
 find product: sql error: sql: no rows in result set
-requestID: 24874020-cab7-4ef3-bac5-76858832f8b0
+request.id: 24874020-cab7-4ef3-bac5-76858832f8b0
+request.method: GET
 sql: SELECT id, name FROM product WHERE id = ?
 productID: 123
 main.main
@@ -140,7 +189,7 @@ runtime.goexit
 
 ### Marshal error into JSON
 
-Wrapped errors implements `json.Marshaler` interface. So you can easily marshal errors into JSON.
+Wrapped errors implement `json.Marshaler` interface. Grouped attributes are marshaled as nested objects.
 
 Example
 
@@ -153,7 +202,10 @@ func main() {
 	)
 	err = errors.Errorf(
 		"find product: %w", err,
-		errors.String("requestID", "24874020-cab7-4ef3-bac5-76858832f8b0"),
+		errors.Group("request",
+			slog.String("id", "24874020-cab7-4ef3-bac5-76858832f8b0"),
+			slog.String("method", "GET"),
+		),
 	)
 	errJSON, err := json.MarshalIndent(err, "", "\t")
 	if err != nil {
@@ -169,7 +221,10 @@ Output
 {
     "error": "find product: sql error: sql: no rows in result set",
     "productID": 123,
-    "requestID": "24874020-cab7-4ef3-bac5-76858832f8b0",
+    "request": {
+        "id": "24874020-cab7-4ef3-bac5-76858832f8b0",
+        "method": "GET"
+    },
     "sql": "SELECT id, name FROM product WHERE id = ?",
     "stackTrace": [
         {
@@ -191,31 +246,117 @@ Output
 }
 ```
 
-### Structured logging
+### Structured logging with slog
 
-To use structured logging, you need to use an adapter for your logging system. It can be one of the 
-built-in adapters from the `logging` directory, or you can implement your own adapter using `errors.Logger` interface.
+The package provides native integration with Go's `log/slog`. Errors implement `slog.LogValuer`,
+so they work seamlessly with any slog logger.
 
-Example of using an adapter for [Logrus](https://github.com/sirupsen/logrus).
+#### Using Log convenience function
 
 ```golang
 err := errors.Errorf(
-	"sql error: %w", sql.ErrNoRows,
-	errors.String("sql", "SELECT id, name FROM product WHERE id = ?"),
-	errors.Int("productID", 123),
+	"database query failed: %w", dbErr,
+	errors.String("query", "SELECT * FROM users WHERE id = ?"),
+	errors.Int("userID", 123),
+	errors.Group("performance",
+		slog.Duration("duration", 250*time.Millisecond),
+		slog.Int("retries", 3),
+	),
 )
-err = errors.Errorf(
-	"find product: %w", err,
-	errors.String("requestID", "24874020-cab7-4ef3-bac5-76858832f8b0"),
+
+// Log error with all attributes and stack trace
+errors.Log(ctx, slog.Default(), slog.LevelError, err)
+```
+
+#### Extracting attributes manually
+
+```golang
+err := errors.Errorf(
+	"operation failed: %w", someErr,
+	errors.String("operation", "user.create"),
+	errors.Int("userID", 123),
 )
-logger := logrus.New()
-logrusadapter.Log(err, logger)
+
+// Extract all attributes from error chain
+attrs := errors.Attrs(err)
+
+// Use with slog
+slog.Error("request failed", append([]any{slog.Any("error", err)}, attrsToAny(attrs)...)...)
 ```
 
-Output
+#### Using slog.LogValuer
 
+Errors automatically work as `slog.LogValuer`, so you can log them directly:
+
+```golang
+err := errors.Wrap(
+	dbErr,
+	errors.String("table", "users"),
+	errors.Int("id", 123),
+)
+
+// The error will automatically provide its attributes to slog
+slog.Error("database error", "error", err)
+```
+
+### Custom LoggableError types
+
+You can implement `errors.LoggableError` interface on your custom error types to provide
+structured attributes:
+
+```golang
+type ValidationError struct {
+	Field   string
+	Value   interface{}
+	Message string
+}
+
+func (e *ValidationError) Error() string {
+	return fmt.Sprintf("validation failed: %s", e.Message)
+}
+
+// Implement errors.LoggableError
+func (e *ValidationError) Attrs() []slog.Attr {
+	return []slog.Attr{
+		slog.String("field", e.Field),
+		slog.Any("value", e.Value),
+		slog.String("validation_message", e.Message),
+	}
+}
+
+// Usage
+err := &ValidationError{
+	Field:   "email",
+	Value:   "invalid-email",
+	Message: "must be a valid email address",
+}
+wrapped := errors.Wrap(err, errors.String("operation", "user.create"))
+
+// All attributes from ValidationError will be included
+attrs := errors.Attrs(wrapped)
 ```
-ERRO[0000] find product: sql error: sql: no rows in result set  productID=123 requestID=24874020-cab7-4ef3-bac5-76858832f8b0 sql="SELECT id, name FROM product WHERE id = ?" stackTrace="[{main.main /home/strider/projects/errors/var/scratch.go 12} {runtime.main /usr/local/go/src/runtime/proc.go 250} {runtime.goexit /usr/local/go/src/runtime/asm_amd64.s 1571}]"
+
+## Available attribute options
+
+The package provides convenience functions for creating attributes:
+
+```golang
+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.String(key string, value string)
+errors.Stringer(key string, value fmt.Stringer)
+errors.Strings(key string, values []string)
+errors.Value(key string, value interface{})
+errors.Time(key string, value time.Time)
+errors.Duration(key string, value time.Duration)
+errors.JSON(key string, value json.RawMessage)
+
+// 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
 ```
 
 ## Contributing