Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

4.8 KB
Raw Blame
package safelog

import (
	"context"
	"fmt"
	"io"
	"log/slog"
	"os"
	"strings"
	"sync"
	"unicode"

	"github.com/pinchtab/pinchtab/internal/sanitize"
)

const DefaultLevel = slog.LevelInfo

// LevelName renders a level the way the config file and --log-level spell it, so a
// surface reporting the level in effect does not spell the default itself.
func LevelName(level slog.Level) string {
	return strings.ToLower(level.String())
}

const (
	MaxStringValueBytes = 2 * 1024
	MaxRecordTextBytes  = 8 * 1024
	redactedValue       = "[REDACTED]"
)

type Handler struct {
	next slog.Handler
}

var (
	installOnce sync.Once
	levelVar    = new(slog.LevelVar)
)

func NewHandler(next slog.Handler) *Handler {
	if next == nil {
		next = slog.Default().Handler()
	}
	return &Handler{next: next}
}

// InstallDefault is the only owner of the process default logger; nothing else
// may call slog.SetDefault.
func InstallDefault() {
	installOnce.Do(func() {
		slog.SetDefault(slog.New(NewDefaultHandler(os.Stderr)))
	})
}

func NewDefaultHandler(w io.Writer) slog.Handler {
	return NewHandler(slog.NewTextHandler(w, &slog.HandlerOptions{Level: levelVar}))
}

// SetLevel adjusts the installed threshold after flags are parsed, which is why
// the level is a LevelVar and not a second slog.SetDefault.
func SetLevel(l slog.Level) {
	levelVar.Set(l)
}

func CurrentLevel() slog.Level {
	return levelVar.Level()
}

func ParseLevel(value string) (slog.Level, error) {
	switch strings.ToLower(strings.TrimSpace(value)) {
	case "":
		return DefaultLevel, nil
	case "debug":
		return slog.LevelDebug, nil
	case "info":
		return slog.LevelInfo, nil
	case "warn", "warning":
		return slog.LevelWarn, nil
	case "error":
		return slog.LevelError, nil
	}
	return DefaultLevel, fmt.Errorf("unknown log level %q (want debug, info, warn or error)", value)
}

func (h *Handler) Enabled(ctx context.Context, level slog.Level) bool {
	return h.next.Enabled(ctx, level)
}

func (h *Handler) Handle(ctx context.Context, rec slog.Record) error {
	budget := MaxRecordTextBytes
	msg, budget := sanitizeText(rec.Message, budget)
	out := slog.NewRecord(rec.Time, rec.Level, msg, rec.PC)

	rec.Attrs(func(attr slog.Attr) bool {
		sanitizedAttr, nextBudget := sanitizeAttr(attr, budget)
		budget = nextBudget
		out.AddAttrs(sanitizedAttr)
		return true
	})

	return h.next.Handle(ctx, out)
}

func (h *Handler) WithAttrs(attrs []slog.Attr) slog.Handler {
	budget := MaxRecordTextBytes
	sanitizedAttrs := make([]slog.Attr, 0, len(attrs))
	for _, attr := range attrs {
		sanitizedAttr, nextBudget := sanitizeAttr(attr, budget)
		budget = nextBudget
		sanitizedAttrs = append(sanitizedAttrs, sanitizedAttr)
	}
	return &Handler{next: h.next.WithAttrs(sanitizedAttrs)}
}

func (h *Handler) WithGroup(name string) slog.Handler {
	return &Handler{next: h.next.WithGroup(name)}
}

func sanitizeAttr(attr slog.Attr, budget int) (slog.Attr, int) {
	attr.Value = attr.Value.Resolve()
	if isSensitiveKey(attr.Key) {
		return slog.String(attr.Key, redactedValue), clampBudget(budget - len(redactedValue))
	}

	switch attr.Value.Kind() {
	case slog.KindString:
		s, nextBudget := sanitizeText(attr.Value.String(), budget)
		return slog.String(attr.Key, s), nextBudget
	case slog.KindGroup:
		group := attr.Value.Group()
		sanitizedGroup := make([]slog.Attr, 0, len(group))
		for _, child := range group {
			sanitizedChild, nextBudget := sanitizeAttr(child, budget)
			budget = nextBudget
			sanitizedGroup = append(sanitizedGroup, sanitizedChild)
		}
		return slog.Attr{Key: attr.Key, Value: slog.GroupValue(sanitizedGroup...)}, budget
	case slog.KindAny:
		switch v := attr.Value.Any().(type) {
		case error:
			s, nextBudget := sanitizeText(v.Error(), budget)
			return slog.String(attr.Key, s), nextBudget
		case fmt.Stringer:
			s, nextBudget := sanitizeText(v.String(), budget)
			return slog.String(attr.Key, s), nextBudget
		case string:
			s, nextBudget := sanitizeText(v, budget)
			return slog.String(attr.Key, s), nextBudget
		case []byte:
			s, nextBudget := sanitizeText(string(v), budget)
			return slog.String(attr.Key, s), nextBudget
		}
	}

	return attr, budget
}

func sanitizeText(s string, budget int) (string, int) {
	limit := MaxStringValueBytes
	if budget < limit {
		limit = budget
	}
	if limit < 0 {
		limit = 0
	}
	s = sanitize.CleanForLog(s, limit)
	return s, clampBudget(budget - len(s))
}

func clampBudget(v int) int {
	if v < 0 {
		return 0
	}
	return v
}

func isSensitiveKey(key string) bool {
	var b strings.Builder
	b.Grow(len(key))
	for _, r := range key {
		if unicode.IsLetter(r) || unicode.IsDigit(r) {
			b.WriteRune(unicode.ToLower(r))
		}
	}
	normalized := b.String()
	if normalized == "" {
		return false
	}
	return strings.Contains(normalized, "password") ||
		strings.Contains(normalized, "cookie") ||
		strings.Contains(normalized, "authorization") ||
		normalized == "token" ||
		strings.HasSuffix(normalized, "token")
}