Trackér událostí pro MVP na Django a SQLite: rychlá analytika

Minimalistický sledovač událostí pro MVP: Django, SQLite a pixel

Při spuštění MVP je klíčové rychle a bez zbytečných nákladů ověřit klíčové uživatelské akce. Namísto připojování robustních analytických systémů lze nasadit lehký Django backend, který prostřednictvím pixelu shromažďuje události a ukládá je v SQLite. Tento přístup šetří čas, nevyžaduje složitou infrastrukturu a umožňuje soustředit se na ověření hypotézy.

Architektura jednoduchého sledovače událostí

Řešení je postaveno na minimalistickém backendu, který se jednou nasadí na hosting a poté obsluhuje více frontendů. Frontend posílá GET požadavek na endpoint /t.gif s parametry události a zdroje. Backend atomárně zvýší čítač v databázi. Pro zobrazení statistiky se používá uzavřený endpoint /api/stats, který vrací data ve formátu JSON.

Klíčové komponenty systému:

• Frontend: Volá track(event, src) pomocí vytvoření objektu Image.
• Backend (Django): Zpracuje požadavek, aktualizuje čítač v SQLite.
• Databáze: Jedna tabulka s poli event, src, count, updated_at.
• API statistiky: Přístup přes klíč, vrací agregovaná data.

Takový sledovač je obzvláště užitečný pro projekty na bezplatných hostinzích, kde je souborový systém ephemeral a služby po nečinnosti přecházejí do spánkového režimu.

Implementace v Django a SQLite

Datový model je velmi jednoduchý a používá unikátní index pro dvojici event a src.

# tracker/models.py
from django.db import models

class Counter(models.Model):
    event = models.CharField(max_length=120)
    src = models.CharField(max_length=120, blank=True, default="")
    count = models.PositiveBigIntegerField(default=0)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        unique_together = ("event", "src")

    def __str__(self) -> str:
        return f"{self.src}:{self.event}={self.count}"

Endpoint pro zaznamenání události používá pixel 1×1 zakódovaný v base64. To umožňuje vyhnout se problémům s CORS a nevyžaduje další klientské knihovny.

# tracker/views.py
import base64

from django.conf import settings
from django.db import transaction
from django.db.models import F
from django.http import HttpResponse, JsonResponse
from django.views.decorators.http import require_GET

from .models import Counter

_GIF_1x1 = base64.b64decode(
    "R0lGODlhAQABAPAAAAAAAAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw=="
)

@require_GET
def pixel(request):
    event = _clean(request.GET.get("e", ""), 120)
    src = _clean(request.GET.get("src", ""), 120)

    if not event:
        return _gif_response()

    with transaction.atomic():
        obj, created = Counter.objects.get_or_create(event=event, src=src)

        if created:
            obj.count = 1
            obj.save(update_fields=["count"])
        else:
            Counter.objects.filter(pk=obj.pk).update(count=F("count") + 1)

    return _gif_response()

Atomární aktualizace přes F("count") + 1 zaručuje správnost dat při paralelních požadavcích. Endpoint statistiky filtruje data podle události a zdroje, pokud jsou parametry předány.

Integrace s frontendem v Next.js

Na straně klienta se používá univerzální pomocník, který lze přenášet mezi projekty beze změn.

// src/utils/track.ts
const TRACK_BASE = "https://your-domain.com/t.gif";

export const track = (event: string, src: string) => {
  const img = new Image();
  img.src =
    `${TRACK_BASE}?` +
    `e=${encodeURIComponent(event)}` +
    `&src=${encodeURIComponent(src)}` +
    `&t=${Date.now()}`;
};

Příklad použití v komponentě Next.js pro sledování kliknutí na tlačítko vytvoření projektu:

// src/app/_ui/HomePageClient.tsx
"use client";

import { useRouter } from "next/navigation";
import { track } from "@/utils/track";

export default function HomePageClient() {
  const router = useRouter();

  return (
    <section className="mt-8 space-y-2">
      <div
        className="app-card app-card--soft cursor-pointer hover:border-slate-500/70 hover:bg-white/5 transition-colors"
        role="button"
        tabIndex={0}
        onClick={() => {
          router.push("/demo");
          track("create_project_click", "demo_project");
        }}
      >
        Vytvořit projekt
      </div>
    </section>
  );
}

Poté lze statistiku zobrazit odesláním GET požadavku na /api/stats s autorizačním klíčem. Odpověď obsahuje seznam událostí s počtem spuštění a časem poslední aktualizace.

Výhody a omezení přístupu

Použití lehkého sledovače pro MVP přináší několik praktických výhod:

• Rychlé ověření hypotéz: Zaměření na jednu klíčovou akci namísto mnoha metrik.
• Úspora zdrojů: Není potřeba robustních analytických systémů a samostatných databází.
• Univerzálnost: Jeden backend obsluhuje více frontendů a projektů.
• Jednoduchost nasazení: Minimální požadavky na hosting, vhodné pro bezplatné tarify.

Přesto má přístup přirozená omezení:

• Neexistuje sledování unikátních uživatelů a sezení.
• Chybí nálevky, retence a segmentace.
• Není podpora A/B testování a složitých analytických reportů.

Tyto funkce se stávají nezbytnými v pozdějších fázích vývoje produktu, kdy MVP prokázalo svou životaschopnost.

Co je důležité

• Jedna metrika je lepší než dvacet: Pro MVP je klíčové soustředit se na jednu klíčovou akci, která ověří hlavní hypotézu.
• Minimální infrastruktura: Použití SQLite a pixelu umožňuje vyhnout se komplikacím s nasazením a údržbou.
• Atomárnost operací: Aktualizace čítače přes F("count") + 1 zaručuje správnost dat při vysoké zátěži.
• Univerzální pomocník: Klientská knihovna o 10 řádcích kódu funguje v jakémkoli moderním frontend frameworku.
• Rychlý start: Řešení lze nasadit za pár hodin a okamžitě začít sbírat data.

Takový sledovač nenahrazuje plnohodnotný analytický systém, ale umožňuje rychle a levně získat odpověď na hlavní otázku: Dochází k klíčové akci, pro kterou se MVP vytváří? Pokud k události nedochází, problém je pravděpodobně v samotném produktu, a ne v nedostatku metrik.

— Editorial Team