Email Open Tracking with Go: Tracking Pixels, Unique URLs, and GDPR

package main

import (
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/pixel.png", pixelHandler)

    // ListenAndServe must be at the top level of main, not inside a handler.
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func pixelHandler(w http.ResponseWriter, r *http.Request) {
    log.Printf("open event from %s user-agent=%s", r.RemoteAddr, r.UserAgent())

    w.Header().Set("Content-Type", "image/png")
    w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
    w.Header().Set("Expires", time.Now().UTC().Format(http.TimeFormat))

    // Serve a 1x1 transparent PNG (base64-decoded inline to avoid filesystem dependency).
    w.Write(transparentPNG)
}

// transparentPNG is the smallest valid 1x1 transparent PNG (67 bytes).
var transparentPNG = []byte{
    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
    0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
    0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4,
    0x89, 0x00, 0x00, 0x00, 0x0a, 0x49, 0x44, 0x41,
    0x54, 0x78, 0x9c, 0x62, 0x00, 0x01, 0x00, 0x00,
    0x05, 0x00, 0x01, 0x0d, 0x0a, 0x2d, 0xb4, 0x00,
    0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
    0x42, 0x60, 0x82,
}

package tracker

import (
    "sync"
    "time"
)

// TrackingRecord stores metadata about a single email send.
type TrackingRecord struct {
    RecipientEmail string
    Subject        string
    SentAt         time.Time
    FirstOpenAt    *time.Time
    OpenCount      int
}

// Store is an in-memory open tracking store.
// In production, replace with a database (PostgreSQL, Redis, DynamoDB).
type Store struct {
    mu      sync.RWMutex
    records map[string]*TrackingRecord // key: UUID
}

func NewStore() *Store {
    return &Store{records: make(map[string]*TrackingRecord)}
}

// Register creates a new tracking record and returns its UUID.
func (s *Store) Register(uuid, recipient, subject string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.records[uuid] = &TrackingRecord{
        RecipientEmail: recipient,
        Subject:        subject,
        SentAt:         time.Now(),
    }
}

// RecordOpen marks the tracking record as opened. Thread-safe.
// Returns the record, or nil if the UUID is unknown.
func (s *Store) RecordOpen(uuid string) *TrackingRecord {
    s.mu.Lock()
    defer s.mu.Unlock()
    rec, ok := s.records[uuid]
    if !ok {
        return nil
    }
    now := time.Now()
    if rec.FirstOpenAt == nil {
        rec.FirstOpenAt = &now
    }
    rec.OpenCount++
    return rec
}

package tracker

import (
    "log/slog"
    "net/http"
    "strings"
    "time"
)

type Server struct {
    store *Store
    mux   *http.ServeMux
}

func NewServer(store *Store) *Server {
    s := &Server{store: store, mux: http.NewServeMux()}
    s.mux.HandleFunc("/pixel/", s.handlePixel)
    return s
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    s.mux.ServeHTTP(w, r)
}

// handlePixel handles GET /pixel/{uuid}.png
func (s *Server) handlePixel(w http.ResponseWriter, r *http.Request) {
    // Extract UUID from path: /pixel/550e8400-e29b-41d4-a716-446655440000.png
    path := strings.TrimPrefix(r.URL.Path, "/pixel/")
    uuid := strings.TrimSuffix(path, ".png")

    rec := s.store.RecordOpen(uuid)
    if rec != nil {
        slog.Info("email opened",
            "uuid", uuid,
            "recipient", rec.RecipientEmail,
            "subject", rec.Subject,
            "open_count", rec.OpenCount,
            "user_agent", r.UserAgent(),
            "remote_addr", r.RemoteAddr,
        )
    } else {
        slog.Warn("unknown tracking UUID", "uuid", uuid)
    }

    // Always serve the pixel -- even for unknown UUIDs.
    // Returning 404 causes retry storms from aggressive email clients.
    w.Header().Set("Content-Type", "image/png")
    w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
    w.Header().Set("Pragma", "no-cache")
    w.Header().Set("Expires", time.Now().UTC().Format(http.TimeFormat))
    w.WriteHeader(http.StatusOK)
    w.Write(transparentPNG)
}

package mailer

import (
    "crypto/rand"
    "fmt"
    "tracker"
)

func newUUID() string {
    b := make([]byte, 16)
    rand.Read(b)
    return fmt.Sprintf("%08x-%04x-%04x-%04x-%12x",
        b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
}

func SendTrackedEmail(store *tracker.Store, recipient, subject, baseURL string) {
    uuid := newUUID()
    store.Register(uuid, recipient, subject)

    pixelURL := fmt.Sprintf("%s/pixel/%s.png", baseURL, uuid)
    html := buildEmailHTML(subject, pixelURL)

    // Send html via your SMTP library here.
    _ = html
}

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>{{.Subject}}</title>
</head>
<body>
  <p>Hello {{.RecipientName}},</p>

  <p>{{.Body}}</p>

  <p>Best regards,<br>The Team</p>

  <!--
    Tracking pixel: 1x1 transparent PNG.
    width/height=1 prevents layout shift.
    alt="" prevents screen readers from announcing it.
    Placed at the end of body to avoid blocking render.
  -->
  <img src="{{.PixelURL}}"
       width="1" height="1"
       alt=""
       style="display:block;width:1px;height:1px;border:0;" />
</body>
</html>