refactor: simplify logging functions and introduce LogLevel

This commit refactors the logging functions by removing the level parameter from the Log function, making it a shorthand for logging at the Error level. A new LogLevel function is introduced to allow logging at specified levels. Additionally, tests are updated to reflect these changes, and documentation is revised to guide users on the new logging approach.

Author: strider2038

MIGRATION.md

@@ -14,14 +14,14 @@ Version 0.5.0 is a **breaking change** release that replaces the custom field sy
 - ✅ **Added**: `slog.LogValuer` implementation
 - ✅ **Added**: Grouped attributes via `slog.Group`
 - ✅ **Added**: `errors.Attrs(err)` to extract attributes
-- ✅ **Added**: `errors.Log(ctx, logger, level, err)` for slog logging
+- ✅ **Added**: `errors.Log(ctx, logger, err)` and `errors.LogLevel(ctx, logger, level, err)` for slog logging
 - 📦 **Minimum Go version**: 1.21 (for `log/slog` support)
 
 ## Quick Migration Checklist
 
 - [ ] Update Go version to 1.21 or higher
 - [ ] Remove imports of `errors/logging/logrusadapter`
-- [ ] Replace old `errors.Log(err, logger)` calls with new `errors.Log(ctx, logger, level, err)` or direct slog usage
+- [ ] Replace old `errors.Log(err, logger)` calls with new `errors.Log(ctx, logger, err)` or `errors.LogLevel(ctx, logger, level, err)` or direct slog usage
 - [ ] Update custom error types implementing `LoggableError`
 - [ ] Update mock loggers in tests to use `errorstest.Logger`
 - [ ] Consider using grouped attributes for better structure
@@ -326,7 +326,7 @@ If you were using the logrus adapter:
 - logrusadapter.Log(err, logrusLogger)
 
 // Option 1: Switch to slog
-+ errors.Log(ctx, slog.Default(), slog.LevelError, err)
++ errors.Log(ctx, slog.Default(), err)
 
 // Option 2: Create your own logrus adapter
 + // See "Custom Logger Adapters" section below
@@ -378,7 +378,7 @@ Replace `errors.Log()` calls:
 - errors.Log(err, myLogger)
 
 + // Option 1: Use Log
-+ errors.Log(ctx, slog.Default(), slog.LevelError, err)
++ errors.Log(ctx, slog.Default(), err)
 
 + // Option 2: Extract and log
 + attrs := errors.Attrs(err)
@@ -516,7 +516,7 @@ logger := otelslog.NewHandler(...)
 logger := slog.New(myHandler)
 
 // Works the same way
-errors.Log(ctx, logger, slog.LevelError, err)
+errors.Log(ctx, logger, err)
 ```
 
 ### 4. Simplified Testing
@@ -562,7 +562,7 @@ func (e *MyError) Attrs() []slog.Attr {
 **Solution**: Convert to `[]any` or use `Log()`:
 ```go
 // Option 1: Use Log
-errors.Log(ctx, logger, level, err)
+errors.LogLevel(ctx, logger, level, err)
 
 // Option 2: Convert manually
 attrs := errors.Attrs(err)

README.md

@@ -36,7 +36,7 @@ Key differences and 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.
+* `errors.Log(ctx, logger, err)` and `errors.LogLevel(ctx, logger, level, err)` for logging with slog.
 
 ## Installation
 
@@ -318,8 +318,8 @@ err := errors.Errorf(
 	),
 )
 
-// Log error with all attributes and stack trace
-errors.Log(ctx, slog.Default(), slog.LevelError, err)
+// Log error at Error level with all attributes and stack trace
+errors.Log(ctx, slog.Default(), err)
 ```
 
 #### Extracting attributes manually

logging.go

@@ -43,17 +43,29 @@ func attrsFromError(err error) []slog.Attr {
 	return attrs
 }
 
-// Log logs an error with all its structured attributes and stack trace
-// using the provided slog.Logger. This is a convenience function for logging
-// errors with slog.
+// Log logs an error at Error level with all its structured attributes and stack trace
+// using the provided slog.Logger. It is a shorthand for LogLevel(ctx, logger, slog.LevelError, err).
 //
 // If err is nil, this function does nothing.
 //
 // Example:
 //
 //	err := errors.Wrap(dbErr, errors.String("query", sql), errors.Int("userID", 123))
-//	errors.Log(ctx, slog.Default(), slog.LevelError, err)
-func Log(ctx context.Context, logger *slog.Logger, level slog.Level, err error) {
+//	errors.Log(ctx, slog.Default(), err)
+func Log(ctx context.Context, logger *slog.Logger, err error) {
+	LogLevel(ctx, logger, slog.LevelError, err)
+}
+
+// LogLevel logs an error at the specified level with all its structured attributes
+// and stack trace using the provided slog.Logger.
+//
+// If err is nil, this function does nothing.
+//
+// Example:
+//
+//	errors.LogLevel(ctx, slog.Default(), slog.LevelWarn, err)
+//	errors.LogLevel(ctx, slog.Default(), slog.LevelError, err)
+func LogLevel(ctx context.Context, logger *slog.Logger, level slog.Level, err error) {
 	if err == nil {
 		return
 	}

logging_test.go

@@ -107,7 +107,7 @@ func TestLog(t *testing.T) {
 		errors.Errorf("test error", errors.String("user", "john"), errors.Int("id", 123)),
 	)
 
-	errors.Log(context.Background(), logger, slog.LevelError, err)
+	errors.Log(context.Background(), logger, err)
 
 	if capturedMsg != "test error" {
 		t.Errorf("expected message 'test error', got '%s'", capturedMsg)
@@ -149,6 +149,26 @@ func TestLog(t *testing.T) {
 	}
 }
 
+func TestLogLevel(t *testing.T) {
+	for _, level := range []slog.Level{slog.LevelDebug, slog.LevelInfo, slog.LevelWarn, slog.LevelError} {
+		t.Run(level.String(), func(t *testing.T) {
+			var capturedLevel slog.Level
+			handler := &testHandler{
+				onHandle: func(ctx context.Context, r slog.Record) error {
+					capturedLevel = r.Level
+					return nil
+				},
+			}
+			logger := slog.New(handler)
+			err := errors.New("test")
+			errors.LogLevel(context.Background(), logger, level, err)
+			if capturedLevel != level {
+				t.Errorf("expected level %v, got %v", level, capturedLevel)
+			}
+		})
+	}
+}
+
 // testHandler is a simple slog.Handler for testing.
 type testHandler struct {
 	onHandle func(ctx context.Context, r slog.Record) error

slog_test.go

@@ -443,7 +443,7 @@ func TestLogAttrsComplete(t *testing.T) {
 			),
 		)
 
-		errors.Log(context.Background(), logger, slog.LevelError, err)
+		errors.Log(context.Background(), logger, err)
 
 		if capturedMsg != "database error" {
 			t.Errorf("expected message 'database error', got '%s'", capturedMsg)
@@ -497,7 +497,7 @@ func TestLogAttrsComplete(t *testing.T) {
 
 		logger := slog.New(handler)
 
-		errors.Log(context.Background(), logger, slog.LevelError, nil)
+		errors.Log(context.Background(), logger, nil)
 
 		if handlerCalled {
 			t.Error("expected handler not to be called for nil error")
@@ -527,7 +527,7 @@ func TestLogAttrsComplete(t *testing.T) {
 			),
 		)
 
-		errors.Log(context.Background(), logger, slog.LevelError, err)
+		errors.Log(context.Background(), logger, err)
 
 		// Should have request group and stackTrace
 		hasRequestGroup := false