log, regexp & text/template

Text processing in production Go spans logs, pattern matching, and rendered output.

log/slog structures events for observability pipelines.

regexp extracts and validates text with predictable performance.

text/template and html/template generate emails, CLIs, and HTML without string concatenation bugs.

Summary

Migrate new services to slog with JSON handlers and level filters.

Keep package log only where migration cost exceeds benefit.

Precompile regular expressions at package init or startup, not per request.

Choose html/template whenever output lands in browsers to get contextual auto-escaping.

Recipe

Quick-reference recipe card - copy-paste ready.

import (
    "log/slog"
    "os"
    "regexp"
    "text/template"
)
 
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
 
var reUUID = regexp.MustCompile(`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`)
 
tmpl := template.Must(template.New("mail").Parse("Hello {{.Name}}\n"))

When to reach for this:

• Emitting structured logs with levels and attributes for Loki, Elasticsearch, or CloudWatch.
• Parsing log lines, validating identifiers, or rewriting config text.
• Generating reports, Helm-style manifests, or email bodies from data structs.
• Escaping user content in HTML responses with html/template.

Working Example

package main
 
import (
    "bytes"
    "errors"
    "html/template"
    "log/slog"
    "os"
    "regexp"
    "text/template"
)
 
type User struct {
    Name  string
    Email string
}
 
var emailRe = regexp.MustCompile(`^[^@\s]+@[^@\s]+\.[^@\s]+$`)
 
func validateAndRender(u User) (string, error) {
    if !emailRe.MatchString(u.Email) {
        return "", ErrInvalidEmail
    }
 
    slog.Info("render welcome",
        slog.String("user", u.Name),
        slog.String("email", u.Email),
    )
 
    textT := template.Must(template.New("text").Parse("Welcome {{.Name}} <{{.Email}}>"))
    var textBuf bytes.Buffer
    if err := textT.Execute(&textBuf, u); err != nil {
        return "", err
    }
 
    htmlT := template.Must(template.New("html").Parse(`<p>Welcome <b>{{.Name}}</b></p>`))
    var htmlBuf bytes.Buffer
    if err := htmlT.Execute(&htmlBuf, u); err != nil {
        return "", err
    }
 
    return htmlBuf.String(), nil
}
 
var ErrInvalidEmail = errors.New("invalid email")
 
func main() {
    slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})))
 
    out, err := validateAndRender(User{Name: "Ada", Email: "ada@example.com"})
    if err != nil {
        panic(err)
    }
    println(out)
}

What this demonstrates:

• Compiled regex reused across calls.
• slog.Info with typed attributes.
• Parallel text/template and html/template pipelines from one struct.
• template.Must for parse-time failure at startup when moved to init.

Deep Dive

How It Works

• slog routes records through a Handler (JSONHandler, TextHandler, or custom) with level gating.
• regexp compiles patterns to automata with RE2 syntax (no backreferences).
• Templates execute against Go values using {{.Field}} and actions like range and if.
• html/template applies contextual escaping rules per HTML, JS, URL, and CSS contexts.

Logging Comparison

Go Notes

// Attach request ID across handlers:
logger := slog.With(slog.String("request_id", id))
logger.Info("handled", slog.Int("status", 200))
 
// Regex submatches:
parts := re.FindStringSubmatch(line)
 
// Template func map:
tmpl.Funcs(template.FuncMap{"upper": strings.ToUpper})

Gotchas

• Compiling regex per request - CPU spikes under traffic. Fix: regexp.MustCompile at init or use sync.Once.
• Using text/template for HTML pages - XSS when user names contain <script>. Fix: html/template for browser output.
• Logging sensitive fields - PII and tokens in JSON logs violate compliance. Fix: redact attributes; use allowlists.
• Global slog default unset - Libraries log to discarded handler. Fix: slog.SetDefault in main early; accept *slog.Logger in packages.
• Complex regex for HTML parsing - Fragile and slow compared to parsers. Fix: use encoding/json, html tokenizer, or proper parsers.
• Template nil pointer dereference - Execute panics on missing fields. Fix: use {{if .Optional}} or pointer checks in data structs.

Alternatives

FAQs

Related

• Standard Library Basics - fmt and string basics before templating
• os, io, bufio & path/filepath - Reading template files from disk
• The Go Standard Library: Batteries Included - slog as modern stdlib path
• runtime, debug & pprof Packages - Correlating logs with profiles
• Standard Library Best Practices - Logging and regex discipline

Stack versions: This page was written for Go 1.26.x (Green Tea GC default, go fix modernizers - verify patch at build), chi (latest - verify at build), gin (latest - verify at build), echo (latest - verify at build), google.golang.org/grpc (latest - verify at build), sigs.k8s.io/controller-runtime (latest - verify at build), kubebuilder (latest - verify at build), tinygo (latest - verify board targets at build), wazero (latest - verify at build), and golangci-lint (latest - verify linter set at build).