<lines>

### Feature request (Markdown)

```markdown
### Use case
<problem statement and context>

### Proposal
<shape of SDK surface or behavior>

### Alternatives considered
<brief notes>

### Impact
<users or flows affected; performance/migration notes if any>

### Location
<page/section/file>

### Problem
<unclear/missing/incorrect information>

### Suggested fix
<concrete replacement/addition>

type Logger func(event string, metadata map[string]any)
// The SDK redacts x-api-key before invoking Logger.

%%{init: {'theme': 'base'}}%%
flowchart TD
  A[Incoming ticket] --> B{Security-related?}
  B -->|Yes| S[Private Security Advisory, coordinated disclosure]
  B -->|No| C{Repro provided?}
  C -->|No| D[Request MRE + diagnostics]
  C -->|Yes| E[Classify: bug / question / feature]
  E -->|Bug| F[Confirm on latest patch]
  F --> G{Repro on maintainer env?}
  G -->|Yes| H[Prioritize & fix]
  G -->|No| I[Request env details; proxy/timeouts]
  E -->|Question| Q[Answer or convert to doc task]
  E -->|Feature| R[Review design; label enhancement]

cl := warlot.New(
  warlot.WithLogger(func(evt string, meta map[string]any) {
    // Ship to a secure sink; API key already redacted.
    // Recommended: include timestamp and a correlation ID.
    _ = evt; _ = meta
  }),
)
cl.BeforeHooks = append(cl.BeforeHooks, func(r *http.Request) {
  r.Header.Set("X-Correlation-ID", "diag-"+time.Now().UTC().Format(time.RFC3339Nano))
})

type Product struct {
  ID    int     `json:"id"`
  Name  string  `json:"name"`
  Price float64 `json:"price"`
}

func sample(ctx context.Context, cl *warlot.Client, projectID string) error {
  p := cl.Project(projectID)

  // DDL
  if _, err := p.SQL(ctx, `CREATE TABLE IF NOT EXISTS products (id INTEGER PRIMARY KEY, name TEXT, price REAL)`, nil); err != nil {
    return err
  }
  // DML (with idempotency)
  if _, err := p.SQL(ctx, `INSERT INTO products (id,name,price) VALUES (?,?,?)`,
    []any{1, "A", 2.5}, warlot.WithIdempotencyKey("prod-1")); err != nil {
    return err
  }
  // SELECT (typed)
  rows, err := warlot.Query[Product](ctx, p, `SELECT id,name,price FROM products`, nil)
  if err != nil { return err }
  _ = rows
  return nil
}

func TestSupport_LoggerRedaction(t *testing.T) {
  s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte(`{"ok":true,"row_count":0}`))
  }))
  defer s.Close()

  var seen string
  cl := warlot.New(
    warlot.WithBaseURL(s.URL),
    warlot.WithAPIKey("SENSITIVE-KEY-123456"),
    warlot.WithLogger(func(evt string, m map[string]any) {
      if evt == "request" {
        if h, ok := m["headers"].(http.Header); ok {
          seen = h.Get("x-api-key")
        }
      }
    }),
  )
  _, err := cl.ExecSQL(context.Background(), "P", warlot.SQLRequest{SQL: "CREATE TABLE t(x)"})
  if err != nil { t.Fatal(err) }
  if strings.Contains(seen, "SENSITIVE-KEY") {
    t.Fatalf("API key not redacted in logger: %q", seen)
  }
}

func TestSupport_RetryAfterLogged(t *testing.T) {
  when := time.Now().Add(1*time.Second).UTC().Format(http.TimeFormat)
  s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Retry-After", when)
    http.Error(w, `{"message":"rate"}`, http.StatusTooManyRequests)
  }))
  defer s.Close()

  var sawRetryAfter bool
  cl := warlot.New(
    warlot.WithBaseURL(s.URL),
    warlot.WithRetries(1),
    warlot.WithLogger(func(evt string, m map[string]any) {
      if evt == "response" {
        if st, _ := m["status"].(int); st == 429 { sawRetryAfter = true }
      }
    }),
  )
  _, _ = cl.ExecSQL(context.Background(), "P", warlot.SQLRequest{SQL: "CREATE TABLE t(x)"})
  if !sawRetryAfter { t.Fatalf("Retry-After not observed in diagnostics") }
}