Function Errorf

internal/redact/redact.go:123–160

Errorf creates a redactable error that has an error string identical to that of a [fmt.Errorf] error. Calling [Redact] on the result will redact all format arguments from the error message instead of redacting the entire string. When redacting the error string, Errorf replaces arguments that implem

(format string, a ...any)

//	Errorf("cannot find user %s", Safe(username)).Error()
//	// cannot find user bob
func Errorf(format string, a ...any) error {
	// Capture a stack trace.
	safeErr := &safeError{
		callers: make([]uintptr, 32),
	}
	n := runtime.Callers(2, safeErr.callers)
	safeErr.callers = safeErr.callers[:n]

	// Create the "normal" unredacted error. We need to remove the safe wrapper
	// from any args so that fmt.Errorf can detect and format their type
	// correctly.
	args := make([]any, len(a))
	for i := range a {
		if safe, ok := a[i].(safe); ok {
			args[i] = safe.a
		} else {
			args[i] = a[i]
		}
	}
	safeErr.err = fmt.Errorf(format, args...)

	// Now create the redacted error by replacing all args with their redacted
	// version or by inserting a placeholder if the arg can't be redacted.
	for i := range a {
		switch t := a[i].(type) {
		case safe:
			args[i] = t.a
		case error:
			args[i] = Error(t)
		case redactor:
			args[i] = formatter(t.Redact())
		default:
			args[i] = formatter(placeholder(t))
		}
	}
	safeErr.redacted = fmt.Errorf(format, args...)
	return safeErr
}

// redactor defines the Redact interface for types that can format themselves
// in redacted errors.