diff --git a/slog/benchmarks/benchmarks_test.go b/slog/benchmarks/benchmarks_test.go
index 0611257..50143ab 100644
--- a/slog/benchmarks/benchmarks_test.go
+++ b/slog/benchmarks/benchmarks_test.go
@@ -41,7 +41,7 @@
 					// should only be from Duration.String and Time.String.
 					"5 args",
 					func() {
-						logger.LogAttrs(slog.LevelInfo, TestMessage,
+						logger.LogAttrs(nil, slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
@@ -53,7 +53,7 @@
 				{
 					"5 args ctx",
 					func() {
-						logger.WithContext(ctx).LogAttrs(slog.LevelInfo, TestMessage,
+						logger.LogAttrs(ctx, slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
@@ -65,7 +65,7 @@
 				{
 					"10 args",
 					func() {
-						logger.LogAttrs(slog.LevelInfo, TestMessage,
+						logger.LogAttrs(nil, slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
@@ -82,7 +82,7 @@
 				{
 					"40 args",
 					func() {
-						logger.LogAttrs(slog.LevelInfo, TestMessage,
+						logger.LogAttrs(nil, slog.LevelInfo, TestMessage,
 							slog.String("string", TestString),
 							slog.Int("status", TestInt),
 							slog.Duration("duration", TestDuration),
diff --git a/slog/example_custom_levels_test.go b/slog/example_custom_levels_test.go
index d0ec3a7..b701b44 100644
--- a/slog/example_custom_levels_test.go
+++ b/slog/example_custom_levels_test.go
@@ -74,13 +74,13 @@
 	}.NewTextHandler(os.Stdout)
 
 	logger := slog.New(th)
-	logger.Log(LevelEmergency, "missing pilots")
+	logger.Log(nil, LevelEmergency, "missing pilots")
 	logger.Error("failed to start engines", fmt.Errorf("missing fuel"))
 	logger.Warn("falling back to default value")
-	logger.Log(LevelNotice, "all systems are running")
+	logger.Log(nil, LevelNotice, "all systems are running")
 	logger.Info("initiating launch")
 	logger.Debug("starting background job")
-	logger.Log(LevelTrace, "button clicked")
+	logger.Log(nil, LevelTrace, "button clicked")
 
 	// Output:
 	// sev=EMERGENCY msg="missing pilots"
diff --git a/slog/example_depth_test.go b/slog/example_depth_test.go
index 95df718..34630c1 100644
--- a/slog/example_depth_test.go
+++ b/slog/example_depth_test.go
@@ -8,17 +8,26 @@
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
+	"time"
 
 	"golang.org/x/exp/slog"
 )
 
+// Infof is an example of a user-defined logging function that wraps slog.
+// The log record contains the source position of the caller of Infof.
 func Infof(format string, args ...any) {
-	// Use LogDepth to adjust source line information to point to the caller of Infof.
-	// The 1 passed to LogDepth refers to the caller of LogDepth, namely this function.
-	slog.Default().LogDepth(1, slog.LevelInfo, fmt.Sprintf(format, args...))
+	l := slog.Default()
+	if !l.Enabled(nil, slog.LevelInfo) {
+		return
+	}
+	var pcs [1]uintptr
+	runtime.Callers(2, pcs[:]) // skip [Callers, Infof]
+	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(format, args...), pcs[0])
+	_ = l.Handler().Handle(nil, r)
 }
 
-func ExampleLogger_LogDepth() {
+func Example_wrapping() {
 	defer func(l *slog.Logger) { slog.SetDefault(l) }(slog.Default())
 
 	replace := func(groups []string, a slog.Attr) slog.Attr {
@@ -37,5 +46,5 @@
 	Infof("message, %s", "formatted")
 
 	// Output:
-	// level=INFO source=example_depth_test.go:37 msg="message, formatted"
+	// level=INFO source=example_depth_test.go:46 msg="message, formatted"
 }
diff --git a/slog/json_handler_test.go b/slog/json_handler_test.go
index 2a61136..dfaf00f 100644
--- a/slog/json_handler_test.go
+++ b/slog/json_handler_test.go
@@ -171,7 +171,7 @@
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
-				l.LogAttrs(LevelInfo, "this is a typical log message",
+				l.LogAttrs(nil, LevelInfo, "this is a typical log message",
 					String("module", "github.com/google/go-cmp"),
 					String("version", "v1.23.4"),
 					Int("count", 23),
@@ -232,7 +232,7 @@
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
-				l.LogAttrs(LevelInfo, "this is a typical log message",
+				l.LogAttrs(nil, LevelInfo, "this is a typical log message",
 					String("module", "github.com/google/go-cmp"),
 					String("version", "v1.23.4"),
 					Int("count", 23),
diff --git a/slog/logger.go b/slog/logger.go
index 7c37db8..1ba8463 100644
--- a/slog/logger.go
+++ b/slog/logger.go
@@ -73,7 +73,6 @@
 // that begins "With".
 type Logger struct {
 	handler Handler // for structured logging
-	ctx     context.Context
 }
 
 func (l *Logger) clone() *Logger {
@@ -84,9 +83,6 @@
 // Handler returns l's Handler.
 func (l *Logger) Handler() Handler { return l.handler }
 
-// Context returns l's context, which may be nil.
-func (l *Logger) Context() context.Context { return l.ctx }
-
 // With returns a new Logger that includes the given arguments, converted to
 // Attrs as in [Logger.Log] and resolved.
 // The Attrs will be added to each output from the Logger.
@@ -120,15 +116,6 @@
 
 }
 
-// WithContext returns a new Logger with the same handler
-// as the receiver and the given context.
-// It uses the same handler as the original.
-func (l *Logger) WithContext(ctx context.Context) *Logger {
-	c := l.clone()
-	c.ctx = ctx
-	return c
-}
-
 // New creates a new Logger with the given non-nil Handler and a nil context.
 func New(h Handler) *Logger {
 	if h == nil {
@@ -142,9 +129,9 @@
 	return Default().With(args...)
 }
 
-// Enabled reports whether l emits log records at the given level.
-func (l *Logger) Enabled(level Level) bool {
-	return l.Handler().Enabled(l.ctx, level)
+// Enabled reports whether l emits log records at the given context and level.
+func (l *Logger) Enabled(ctx context.Context, level Level) bool {
+	return l.Handler().Enabled(ctx, level)
 }
 
 // NewLogLogger returns a new log.Logger such that each call to its Output method
@@ -164,73 +151,115 @@
 //     the following argument is treated as the value and the two are combined
 //     into an Attr.
 //   - Otherwise, the argument is treated as a value with key "!BADKEY".
-func (l *Logger) Log(level Level, msg string, args ...any) {
-	l.LogDepth(1, level, msg, args...)
+func (l *Logger) Log(ctx context.Context, level Level, msg string, args ...any) {
+	l.logDepth(ctx, 1, level, msg, args...)
 }
 
-func (l *Logger) logPC(err error, pc uintptr, level Level, msg string, args ...any) {
+func (l *Logger) logPC(ctx context.Context, err error, pc uintptr, level Level, msg string, args ...any) {
 	r := NewRecord(time.Now(), level, msg, pc)
 	if err != nil {
 		r.front[0] = Any(ErrorKey, err)
 		r.nFront++
 	}
-	r.setAttrsFromArgs(args)
-	_ = l.Handler().Handle(l.ctx, r)
+	r.Add(args...)
+	_ = l.Handler().Handle(ctx, r)
 }
 
 // LogAttrs is a more efficient version of [Logger.Log] that accepts only Attrs.
-func (l *Logger) LogAttrs(level Level, msg string, attrs ...Attr) {
-	l.LogAttrsDepth(1, level, msg, attrs...)
+func (l *Logger) LogAttrs(ctx context.Context, level Level, msg string, attrs ...Attr) {
+	l.logAttrsDepth(ctx, 1, level, msg, attrs...)
 }
 
 // Debug logs at LevelDebug.
 func (l *Logger) Debug(msg string, args ...any) {
-	l.LogDepth(1, LevelDebug, msg, args...)
+	l.logDepth(nil, 1, LevelDebug, msg, args...)
+}
+
+// DebugCtx logs at LevelDebug with the given context.
+func (l *Logger) DebugCtx(ctx context.Context, msg string, args ...any) {
+	l.logDepth(ctx, 1, LevelDebug, msg, args...)
 }
 
 // Info logs at LevelInfo.
 func (l *Logger) Info(msg string, args ...any) {
-	l.LogDepth(1, LevelInfo, msg, args...)
+	l.logDepth(nil, 1, LevelInfo, msg, args...)
+}
+
+// InfoCtx logs at LevelInfo with the given context.
+func (l *Logger) InfoCtx(ctx context.Context, msg string, args ...any) {
+	l.logDepth(ctx, 1, LevelInfo, msg, args...)
 }
 
 // Warn logs at LevelWarn.
 func (l *Logger) Warn(msg string, args ...any) {
-	l.LogDepth(1, LevelWarn, msg, args...)
+	l.logDepth(nil, 1, LevelWarn, msg, args...)
+}
+
+// WarnCtx logs at LevelWarn with the given context.
+func (l *Logger) WarnCtx(ctx context.Context, msg string, args ...any) {
+	l.logDepth(ctx, 1, LevelWarn, msg, args...)
 }
 
 // Error logs at LevelError.
 // If err is non-nil, Error adds Any(ErrorKey, err)
 // before the list of attributes.
 func (l *Logger) Error(msg string, err error, args ...any) {
-	l.logDepthErr(err, 1, LevelError, msg, args...)
+	l.logDepthErr(nil, err, 1, LevelError, msg, args...)
+}
+
+// ErrorCtx logs at LevelError with the given context.
+// If err is non-nil, it adds Any(ErrorKey, err)
+// before the list of attributes.
+func (l *Logger) ErrorCtx(ctx context.Context, msg string, err error, args ...any) {
+	l.logDepthErr(ctx, err, 1, LevelError, msg, args...)
 }
 
 // Debug calls Logger.Debug on the default logger.
 func Debug(msg string, args ...any) {
-	Default().LogDepth(1, LevelDebug, msg, args...)
+	Default().logDepth(nil, 1, LevelDebug, msg, args...)
+}
+
+// DebugCtx calls Logger.DebugCtx on the default logger.
+func DebugCtx(ctx context.Context, msg string, args ...any) {
+	Default().logDepth(ctx, 1, LevelDebug, msg, args...)
 }
 
 // Info calls Logger.Info on the default logger.
 func Info(msg string, args ...any) {
-	Default().LogDepth(1, LevelInfo, msg, args...)
+	Default().logDepth(nil, 1, LevelInfo, msg, args...)
+}
+
+// InfoCtx calls Logger.InfoCtx on the default logger.
+func InfoCtx(ctx context.Context, msg string, args ...any) {
+	Default().logDepth(ctx, 1, LevelInfo, msg, args...)
 }
 
 // Warn calls Logger.Warn on the default logger.
 func Warn(msg string, args ...any) {
-	Default().LogDepth(1, LevelWarn, msg, args...)
+	Default().logDepth(nil, 1, LevelWarn, msg, args...)
+}
+
+// WarnCtx calls Logger.WarnCtx on the default logger.
+func WarnCtx(ctx context.Context, msg string, args ...any) {
+	Default().logDepth(ctx, 1, LevelWarn, msg, args...)
 }
 
 // Error calls Logger.Error on the default logger.
 func Error(msg string, err error, args ...any) {
-	Default().logDepthErr(err, 1, LevelError, msg, args...)
+	Default().logDepthErr(nil, err, 1, LevelError, msg, args...)
+}
+
+// ErrorCtx calls Logger.ErrorCtx on the default logger.
+func ErrorCtx(ctx context.Context, msg string, err error, args ...any) {
+	Default().logDepthErr(ctx, err, 1, LevelError, msg, args...)
 }
 
 // Log calls Logger.Log on the default logger.
-func Log(level Level, msg string, args ...any) {
-	Default().LogDepth(1, level, msg, args...)
+func Log(ctx context.Context, level Level, msg string, args ...any) {
+	Default().logDepth(ctx, 1, level, msg, args...)
 }
 
 // LogAttrs calls Logger.LogAttrs on the default logger.
-func LogAttrs(level Level, msg string, attrs ...Attr) {
-	Default().LogAttrsDepth(1, level, msg, attrs...)
+func LogAttrs(ctx context.Context, level Level, msg string, attrs ...Attr) {
+	Default().logAttrsDepth(ctx, 1, level, msg, attrs...)
 }
diff --git a/slog/logger_test.go b/slog/logger_test.go
index 5d5ed07..529a1c6 100644
--- a/slog/logger_test.go
+++ b/slog/logger_test.go
@@ -48,10 +48,10 @@
 	l.Error("bad", io.EOF, "a", 1)
 	check(`level=ERROR msg=bad err=EOF a=1`)
 
-	l.Log(LevelWarn+1, "w", Int("a", 1), String("b", "two"))
+	l.Log(nil, LevelWarn+1, "w", Int("a", 1), String("b", "two"))
 	check(`level=WARN\+1 msg=w a=1 b=two`)
 
-	l.LogAttrs(LevelInfo+1, "a b c", Int("a", 1), String("b", "two"))
+	l.LogAttrs(nil, LevelInfo+1, "a b c", Int("a", 1), String("b", "two"))
 	check(`level=INFO\+1 msg="a b c" a=1 b=two`)
 
 	l.Info("info", "a", []Attr{Int("i", 1)})
@@ -189,9 +189,9 @@
 	startLine = f.Line + 4
 	// Do not change the number of lines between here and the call to check(0).
 
-	logger.Log(LevelInfo, "")
+	logger.Log(nil, LevelInfo, "")
 	check(0)
-	logger.LogAttrs(LevelInfo, "")
+	logger.LogAttrs(nil, LevelInfo, "")
 	check(1)
 	logger.Debug("")
 	check(2)
@@ -209,9 +209,9 @@
 	check(8)
 	Error("", nil)
 	check(9)
-	Log(LevelInfo, "")
+	Log(nil, LevelInfo, "")
 	check(10)
-	LogAttrs(LevelInfo, "")
+	LogAttrs(nil, LevelInfo, "")
 	check(11)
 }
 
@@ -230,7 +230,7 @@
 		wantAllocs(t, 0, func() { dl.Info("hello") })
 	})
 	t.Run("logger.Log", func(t *testing.T) {
-		wantAllocs(t, 0, func() { dl.Log(LevelDebug, "hello") })
+		wantAllocs(t, 0, func() { dl.Log(nil, LevelDebug, "hello") })
 	})
 	t.Run("2 pairs", func(t *testing.T) {
 		s := "abc"
@@ -247,7 +247,7 @@
 		s := "abc"
 		i := 2000
 		wantAllocs(t, 2, func() {
-			l.Log(LevelInfo, "hello",
+			l.Log(nil, LevelInfo, "hello",
 				"n", i,
 				"s", s,
 			)
@@ -258,8 +258,8 @@
 		s := "abc"
 		i := 2000
 		wantAllocs(t, 0, func() {
-			if l.Enabled(LevelInfo) {
-				l.Log(LevelInfo, "hello",
+			if l.Enabled(nil, LevelInfo) {
+				l.Log(nil, LevelInfo, "hello",
 					"n", i,
 					"s", s,
 				)
@@ -281,30 +281,30 @@
 		wantAllocs(t, 0, func() { dl.Info("", "error", io.EOF) })
 	})
 	t.Run("attrs1", func(t *testing.T) {
-		wantAllocs(t, 0, func() { dl.LogAttrs(LevelInfo, "", Int("a", 1)) })
-		wantAllocs(t, 0, func() { dl.LogAttrs(LevelInfo, "", Any("error", io.EOF)) })
+		wantAllocs(t, 0, func() { dl.LogAttrs(nil, LevelInfo, "", Int("a", 1)) })
+		wantAllocs(t, 0, func() { dl.LogAttrs(nil, LevelInfo, "", Any("error", io.EOF)) })
 	})
 	t.Run("attrs3", func(t *testing.T) {
 		wantAllocs(t, 0, func() {
-			dl.LogAttrs(LevelInfo, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
+			dl.LogAttrs(nil, LevelInfo, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
 		})
 	})
 	t.Run("attrs3 disabled", func(t *testing.T) {
 		logger := New(discardHandler{disabled: true})
 		wantAllocs(t, 0, func() {
-			logger.LogAttrs(LevelInfo, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
+			logger.LogAttrs(nil, LevelInfo, "hello", Int("a", 1), String("b", "two"), Duration("c", time.Second))
 		})
 	})
 	t.Run("attrs6", func(t *testing.T) {
 		wantAllocs(t, 1, func() {
-			dl.LogAttrs(LevelInfo, "hello",
+			dl.LogAttrs(nil, LevelInfo, "hello",
 				Int("a", 1), String("b", "two"), Duration("c", time.Second),
 				Int("d", 1), String("e", "two"), Duration("f", time.Second))
 		})
 	})
 	t.Run("attrs9", func(t *testing.T) {
 		wantAllocs(t, 1, func() {
-			dl.LogAttrs(LevelInfo, "hello",
+			dl.LogAttrs(nil, LevelInfo, "hello",
 				Int("a", 1), String("b", "two"), Duration("c", time.Second),
 				Int("d", 1), String("e", "two"), Duration("f", time.Second),
 				Int("d", 1), String("e", "two"), Duration("f", time.Second))
@@ -325,7 +325,7 @@
 		{[]any{"a", 1, 2, 3}, []Attr{Int("a", 1), Int(badKey, 2), Int(badKey, 3)}},
 	} {
 		r := NewRecord(time.Time{}, 0, "", 0)
-		r.setAttrsFromArgs(test.args)
+		r.Add(test.args...)
 		got := attrsSlice(r)
 		if !attrsEqual(got, test.want) {
 			t.Errorf("%v:\ngot  %v\nwant %v", test.args, got, test.want)
@@ -368,46 +368,6 @@
 	checkLogOutput(t, buf.String(), `level=ERROR msg=msg err=EOF !BADKEY=a`)
 }
 
-func TestLogCopying(t *testing.T) {
-	// Verify that Logger methods that purport to set one field of a new Logger
-	// actually do so while preserving the other field.
-
-	h := &captureHandler{} // Use a captureHandler for convenience.
-	l := New(h)
-	ctx := context.WithValue(context.Background(), "v", 0)
-
-	checkContext := func(l *Logger) {
-		t.Helper()
-		ctx := l.Context()
-		if ctx == nil {
-			t.Error("nil context")
-		} else if got, want := ctx.Value("v"), 0; got != want {
-			t.Errorf("for got %v, want %v", got, want)
-		}
-	}
-
-	// WithContext returns a Logger with the given context and the same handler.
-	l2 := l.WithContext(ctx)
-	checkContext(l2)
-	if l2.Handler() != h {
-		t.Error("WithContext changed handler")
-	}
-
-	// With returns a Logger with a different handler but the same context.
-	l3 := l2.With("a", 1)
-	if l3.Handler() == l2.Handler() {
-		t.Error("With did not change handler")
-	}
-	checkContext(l3)
-
-	// WithGroup also returns a Logger with a different handler but the same context.
-	l4 := l3.WithGroup("g")
-	if l4.Handler() == l3.Handler() {
-		t.Error("With did not change handler")
-	}
-	checkContext(l4)
-}
-
 func TestNewLogLogger(t *testing.T) {
 	var buf bytes.Buffer
 	h := NewTextHandler(&buf)
@@ -493,40 +453,40 @@
 	b.Run("no attrs", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.LogAttrs(LevelInfo, "msg")
+			l.LogAttrs(nil, LevelInfo, "msg")
 		}
 	})
 	b.Run("attrs", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+			l.LogAttrs(nil, LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 		}
 	})
 	b.Run("attrs-parallel", func(b *testing.B) {
 		b.ReportAllocs()
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
-				l.LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+				l.LogAttrs(nil, LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 			}
 		})
 	})
 	b.Run("keys-values", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.Log(LevelInfo, "msg", "a", 1, "b", "two", "c", true)
+			l.Log(nil, LevelInfo, "msg", "a", 1, "b", "two", "c", true)
 		}
 	})
 	b.Run("WithContext", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			l.WithContext(ctx).LogAttrs(LevelInfo, "msg2", Int("a", 1), String("b", "two"), Bool("c", true))
+			l.LogAttrs(ctx, LevelInfo, "msg2", Int("a", 1), String("b", "two"), Bool("c", true))
 		}
 	})
 	b.Run("WithContext-parallel", func(b *testing.B) {
 		b.ReportAllocs()
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
-				l.WithContext(ctx).LogAttrs(LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
+				l.LogAttrs(ctx, LevelInfo, "msg", Int("a", 1), String("b", "two"), Bool("c", true))
 			}
 		})
 	})
diff --git a/slog/pc.go b/slog/pc.go
index 2d794a1..6e74bd3 100644
--- a/slog/pc.go
+++ b/slog/pc.go
@@ -7,6 +7,7 @@
 package slog
 
 import (
+	"context"
 	"runtime"
 	"time"
 )
@@ -17,26 +18,26 @@
 // LogDepth is like [Logger.Log], but accepts a call depth to adjust the
 // file and line number in the log record. 1 refers to the caller
 // of LogDepth; 2 refers to the caller's caller; and so on.
-func (l *Logger) LogDepth(calldepth int, level Level, msg string, args ...any) {
-	if !l.Enabled(level) {
+func (l *Logger) logDepth(ctx context.Context, calldepth int, level Level, msg string, args ...any) {
+	if !l.Enabled(ctx, level) {
 		return
 	}
 	var pcs [1]uintptr
 	runtime.Callers(calldepth+2, pcs[:])
-	l.logPC(nil, pcs[0], level, msg, args...)
+	l.logPC(ctx, nil, pcs[0], level, msg, args...)
 }
 
 // LogAttrsDepth is like [Logger.LogAttrs], but accepts a call depth argument
 // which it interprets like [Logger.LogDepth].
-func (l *Logger) LogAttrsDepth(calldepth int, level Level, msg string, attrs ...Attr) {
-	if !l.Enabled(level) {
+func (l *Logger) logAttrsDepth(ctx context.Context, calldepth int, level Level, msg string, attrs ...Attr) {
+	if !l.Enabled(ctx, level) {
 		return
 	}
 	var pcs [1]uintptr
 	runtime.Callers(calldepth+2, pcs[:])
 	r := NewRecord(time.Now(), level, msg, pcs[0])
 	r.AddAttrs(attrs...)
-	_ = l.Handler().Handle(l.ctx, r)
+	_ = l.Handler().Handle(ctx, r)
 }
 
 // logDepthErr is a trivial wrapper around logDepth, just to make the call
@@ -45,13 +46,13 @@
 // TODO: When slog moves to the standard library, replace the fixed call depth
 // with logic based on the Record's pc, and remove this function. See the
 // comment on TestConnections/wrap_default_handler.
-func (l *Logger) logDepthErr(err error, calldepth int, level Level, msg string, args ...any) {
-	if !l.Enabled(level) {
+func (l *Logger) logDepthErr(ctx context.Context, err error, calldepth int, level Level, msg string, args ...any) {
+	if !l.Enabled(ctx, level) {
 		return
 	}
 	var pcs [1]uintptr
 	runtime.Callers(calldepth+2, pcs[:])
-	l.logPC(err, pcs[0], level, msg, args...)
+	l.logPC(ctx, err, pcs[0], level, msg, args...)
 }
 
 // callerPC returns the program counter at the given stack depth.
diff --git a/slog/record.go b/slog/record.go
index 895e505..6911c6c 100644
--- a/slog/record.go
+++ b/slog/record.go
@@ -114,7 +114,10 @@
 	r.back = append(r.back, attrs[n:]...)
 }
 
-func (r *Record) setAttrsFromArgs(args []any) {
+// Add converts the args to Attrs as described in [Logger.Log],
+// then appends the Attrs to the Record's list of Attrs.
+// It resolves the Attrs before doing so.
+func (r *Record) Add(args ...any) {
 	var a Attr
 	for len(args) > 0 {
 		a, args = argsToAttr(args)