Add MaskedString and other utilities

go.mod

@@ -27,6 +27,7 @@ require (
 	go.opentelemetry.io/otel/trace v1.34.0
 	golang.org/x/sync v0.12.0
 	golang.org/x/term v0.30.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
@@ -76,5 +77,4 @@ require (
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250303144028-a0af3efb3deb // indirect
 	google.golang.org/grpc v1.71.0 // indirect
 	google.golang.org/protobuf v1.36.5 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

logger/console_test.go

@@ -4,17 +4,19 @@ import (
 	"bytes"
 	"log"
 	"os"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
 func captureOutput(f func()) string {
+	prev := log.Writer()
 	var buf bytes.Buffer
 	log.SetOutput(&buf)
+	defer log.SetOutput(prev)
 	f()
-	log.SetOutput(nil)
-	return buf.String()
+	return strings.TrimSpace(buf.String())
 }
 
 func TestConsoleLogger(t *testing.T) {

string/mask.go

@@ -1,6 +1,7 @@
 package string
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/url"
 	"regexp"
@@ -70,24 +71,75 @@ var isURL = regexp.MustCompile(`^(\w+)://`)
 var isEmail = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
 var isJWT = regexp.MustCompile(`^[a-zA-Z0-9-_]+\.[a-zA-Z0-9-_]+\.[a-zA-Z0-9-_]+$`)
 
+// MaskValue masks sensitive information in the given argument.
+func MaskValue(arg string) string {
+	if isURL.MatchString(arg) {
+		u, err := MaskURL(arg)
+		if err == nil {
+			return u
+		} else {
+			return Mask(arg)
+		}
+	} else if isEmail.MatchString(arg) {
+		return MaskEmail(arg)
+	} else if isJWT.MatchString(arg) {
+		return Mask(arg)
+	} else {
+		return arg
+	}
+}
+
 // MaskArguments masks sensitive information in the given arguments.
 func MaskArguments(args []string) []string {
 	masked := make([]string, len(args))
 	for i, arg := range args {
-		if isURL.MatchString(arg) {
-			u, err := MaskURL(arg)
-			if err == nil {
-				masked[i] = u
-			} else {
-				masked[i] = Mask(arg)
-			}
-		} else if isEmail.MatchString(arg) {
-			masked[i] = MaskEmail(arg)
-		} else if isJWT.MatchString(arg) {
-			masked[i] = Mask(arg)
-		} else {
-			masked[i] = arg
-		}
+		masked[i] = MaskValue(arg)
 	}
 	return masked
 }
+
+// MaskedString is a custom string type that masks its value when formatted or text-marshaled.
+type MaskedString string
+
+// Text returns the unmasked text value.
+func (ms MaskedString) Text() string {
+	return string(ms)
+}
+
+// Bytes returns the unmasked byte slice value.
+func (ms MaskedString) Bytes() []byte {
+	return []byte(ms.Text())
+}
+
+// String implements fmt.Stringer to return a masked representation.
+func (ms MaskedString) String() string {
+	if len(ms) == 0 {
+		return ""
+	}
+	return Mask(string(ms))
+}
+
+// MarshalText implements encoding.TextMarshaler for masked text output.
+func (ms MaskedString) MarshalText() ([]byte, error) {
+	return []byte(ms.String()), nil
+}
+
+// MarshalJSON implements json.Marshaler for real (unmasked) JSON output.
+func (ms MaskedString) MarshalJSON() ([]byte, error) {
+	return json.Marshal(string(ms))
+}
+
+// MarshalYAML implements yaml.Marshaler for real (unmasked) YAML output.
+func (ms MaskedString) MarshalYAML() (any, error) {
+	return string(ms), nil
+}
+
+// GoString implements fmt.GoStringer so %#v also prints masked.
+func (ms MaskedString) GoString() string {
+	return ms.String()
+}
+
+// NewMaskedString returns a string using the special type MaskedString.
+func NewMaskedString(s string) MaskedString {
+	return MaskedString(s)
+}