Almacenamiento
La disposición del bucket como árbol, el esquema de Postgres con sus tablas principales, cómo se particionan y expiran los datos, cuánto pesa un millón de eventos y qué nunca se guarda.
El motor guarda datos en dos lugares y en ninguno más: un bucket en cualquier almacenamiento compatible con S3, y una base de datos Postgres. Esta página muestra exactamente qué hay en cada uno, hasta los nombres de los objetos y las columnas.
El bucket
Toda llave empieza con el id del proyecto. Debajo, una carpeta por tipo de dato.
events/: los segmentos, los escribe la Ingesta. Eventos crudos, máximo 2 segundos o 4 MiB cada uno.sessions/: los eventos de una sesión, en orden, un archivo por hora. Lo escribe la Consolidación.replays/: fragmentos de grabación, uno cada 10 segundos. Los escribe la Ingesta.snapshots/: capturas de página para los mapas de clics. Las escribe la Ingesta.sourcemaps/: una carpeta por versión. La escribe tu CI.parquet/: los eventos de ayer, compactados. Lo escribe la Consolidación.
Leer este diagrama como texto
Un árbol dibujado como un explorador de archivos. La raíz es tu bucket (más storage.prefix, si pones uno). Debajo hay una carpeta por proyecto, prj_5k2m9x4q7w1z/, y nada se comparte entre proyectos. La carpeta del proyecto tiene seis ramas, cada una con archivos de ejemplo; el mismo árbol está escrito como texto justo debajo de esta figura.
El mismo árbol como texto, para copiar:
prj_5k2m9x4q7w1z/
├── events/production/dt=2026-03-12/hr=09/
│ ├── 20260312T091207Z-2b81e4.ndjson.gz (1) un segmento
│ └── 20260312T091216Z-7f3a9c.ndjson.gz
├── sessions/8f3a6c1e9b2d4f07a5c3e1b8d6f4a2c0/
│ └── hr=2026-03-12-09.ndjson.gz (2) una sesión, un archivo por hora
├── replays/8f3a6c1e9b2d4f07a5c3e1b8d6f4a2c0/
│ ├── 000000.json.gz (3) fragmentos de grabación
│ └── 000001.json.gz
├── snapshots/production/route=checkout/dev=desktop/
│ └── 1773306724000.json.gz (4) una captura de página
├── sourcemaps/4f2a91c/
│ ├── index.json (5) archivo compilado → su mapa
│ └── assets/checkout-3f9c.js.map
└── parquet/production/dt=2026-03-11/
└── events.parquet (6) un día, compactado| # | Prefijo | Lo escribe | Llave | Se conserva (por defecto) |
|---|---|---|---|---|
| 1 | events/ | Ingesta | events/<environment>/dt=<día>/hr=<hora>/<escrito a las>-<escritor>.ndjson.gz. El día y la hora son los de cuando el segmento se escribió, en UTC. <escritor> son 6 caracteres hex que elige el proceso, así dos procesos nunca chocan. | 90 días (retention.events_days) |
| 2 | sessions/ | Consolidación | sessions/<sid>/hr=<día>-<hora>.ndjson.gz. Se escribe de nuevo, completo, cada vez que la consolidación ve eventos nuevos de esa sesión en esa hora. | 90 días |
| 3 | replays/ | Ingesta | replays/<sid>/<seq, 6 dígitos>.json.gz. Enviar el mismo seq otra vez reemplaza el objeto. Máximo 720 por sesión. | 30 días (retention.replays_days) |
| 4 | snapshots/ | Ingesta | snapshots/<environment>/route=<llave de ruta>/dev=<dispositivo>/<ts>.json.gz | 90 días (retention.snapshots_days) |
| 5 | sourcemaps/ | Tu CI, con un enlace que firma la API | sourcemaps/<release>/index.json y sourcemaps/<release>/<ruta>.map | 90 días después de la última vez que se vio la versión |
| 6 | parquet/ | Consolidación, una vez al día | parquet/<environment>/dt=<día>/events.parquet | 90 días |
Los nombres se arman en un solo lugar. Fíjate en que nada en este módulo recibe un texto suelto como proyecto: no se puede armar una llave sin un Scope, y la ruta pasa por una sola función que vuelve cualquier ruta segura como llave.
/// Arma todas las llaves de objeto del motor. El único lugar donde vive la disposición de llaves.
pub struct Keys<'a> {
prefix: &'a str, // `storage.prefix`, normalmente vacío
scope: &'a Scope,
}
impl<'a> Keys<'a> {
/// `<prefix>prj_…/events/production/dt=2026-03-12/hr=09/20260312T091216Z-7f3a9c.ndjson.gz`
pub fn segment(&self, written: DateTime<Utc>, writer: WriterId) -> ObjectKey {
ObjectKey::new(format!(
"{}{}/events/{}/dt={}/hr={}/{}-{}.ndjson.gz",
self.prefix,
self.scope.project,
self.scope.env,
written.format("%Y-%m-%d"),
written.format("%H"),
written.format("%Y%m%dT%H%M%SZ"),
writer, // 6 caracteres hex, fijos mientras viva el proceso
))
}
/// Los fragmentos se ordenan por nombre, así que un listado ya viene en orden de reproducción.
pub fn replay_chunk(&self, sid: &SessionId, seq: u16) -> ObjectKey {
ObjectKey::new(format!("{}{}/replays/{}/{:06}.json.gz", self.prefix, self.scope.project, sid, seq))
}
pub fn snapshot(&self, route: &Route, dev: Device, ts: i64) -> ObjectKey {
ObjectKey::new(format!(
"{}{}/snapshots/{}/route={}/dev={}/{}.json.gz",
self.prefix, self.scope.project, self.scope.env, route_key(route), dev, ts,
))
}
}
/// `/orders/:id` → `orders~_id`. La misma regla del sistema del que sale.
fn route_key(route: &Route) -> String {
let trimmed = route.as_str().trim_start_matches('/');
if trimmed.is_empty() {
return "root".to_owned();
}
trimmed
.chars()
.map(|c| match c {
':' => '_',
'/' => '~',
c if c.is_ascii_alphanumeric() || matches!(c, '_' | '~' | '.' | '-') => c,
_ => '-',
})
.collect()
}Qué hay dentro de un objeto
Un segmento es NDJSON con gzip: un evento por línea, tal como lo envió el SDK después de validarlo, más tres campos que escribe el motor. Esta es la llamada fallida del ejemplo, como queda guardada:
{"v":1,"type":"server_error","ts":1773306724519,"service":"shop-api","env":"production","ver":"4f2a91c","tid":"7c2e9a4b1d8f4e6a9b3c5d7e1f2a4b6c","sid":"8f3a6c1e9b2d4f07a5c3e1b8d6f4a2c0","person":{"id":"u_1042"},"account":{"id":"acc_77"},"method":"POST","path":"/api/checkout","route":"/api/checkout","name":"HTTP 400","msg":"amount is required (POST /v1/payments) in POST /api/checkout","stack":null,"digest":null,"src":"span","span":"3c4d5e6f708192a3","fp":"88a44b15205cb153","prj":"prj_5k2m9x4q7w1z","rcv":1773306725102,"bid":"5d0c7a1e-93b4-4f6a-8e2d-1c7b9a3f5e60"}| Campo sellado | Significado |
|---|---|
prj | El proyecto, tomado de la llave de ingesta. Lo que haya puesto quien envía se reemplaza. |
rcv | Cuándo recibió la ingesta el evento, en milisegundos, según el reloj del motor. |
bid | El batch_id en el que llegó el evento. Así un lote que llegó dos veces se cuenta una. |
Un archivo por sesión empieza con una línea de encabezado y sigue con los eventos de la sesión en esa hora, ordenados por ts, cada uno igual que en su segmento. El encabezado le dice a quien lee qué tiene sin leer el archivo:
{"type":"_session","v":1,"prj":"prj_5k2m9x4q7w1z","env":"production","sid":"8f3a6c1e9b2d4f07a5c3e1b8d6f4a2c0","hour":"2026-03-12T09:00:00Z","events":14,"first_ts":1773306690000,"last_ts":1773306731400,"server_records":2,"written_at":"2026-03-12T09:15:03Z"}Un fragmento de grabación y una captura de página son el cuerpo que envió el SDK, con gzip, guardados con Content-Type: application/json y Content-Encoding: gzip para que un navegador los traiga por un enlace firmado y reciba JSON. El motor no mira adentro: el enmascarado ocurrió en el navegador.
El archivo Parquet tiene una columna con tipo por cada campo del esquema de eventos y una más, extra, un texto JSON con todos los campos que el motor no conocía. Su esquema lo fija la versión del motor, no se adivina de los datos del día. El motor nunca lee estos archivos. Son para ti: cualquier herramienta que lea Parquet puede consultar un día de eventos.
Postgres
Postgres guarda lo que lee una pantalla o una llamada de MCP. Toda tabla empieza con project_id.
projects: todas las demás tablas llevan suproject_id.segments: el registro. Una fila por segmento del Bucket, con cuándo lo revisó la Vía rápida y cuándo lo contó la Consolidación.problems: una fila por problema. De ella cuelgan sus ocurrencias, a quién afectó, los vínculos con trazas, los análisis y las alertas.perf_pages_hourly: una fila por hora, ruta y dispositivo, con un histograma en vez de un promedio.
Leer este diagrama como texto
Diecinueve tablas en cuatro grupos; una línea con pata de gallo es una relación de uno a muchos y llega a la columna que usa. Quién entra: projects tiene muchas ingest_keys y muchos api_tokens. El registro: segments tiene muchos ingest_batches; hours va sola. Problemas, los escribe la Vía rápida: problems tiene muchas problem_occurrences, problem_hits, trace_failures, analyses y alerts. Números, los escribe la Consolidación: sessions, traces, perf_pages_hourly, perf_api_hourly, clicks_daily, usage_daily y uptime_results. Dos vínculos más sueltos cruzan entre los dos últimos grupos: problem_hits.key apunta a sessions.sid, y traces.trace_id a trace_failures.trace_id.
Quién entra
CREATE TABLE projects (
id text PRIMARY KEY CHECK (id ~ '^prj_[0-9a-z]{12}$'),
slug text NOT NULL UNIQUE,
name text NOT NULL,
settings jsonb NOT NULL DEFAULT '{}', -- reglas de grabación, rutas bloqueadas, números de alertas, idioma del agente
limits jsonb NOT NULL DEFAULT '{}', -- eventos y grabaciones por mes; ausente o 0 = sin límite
slow_down jsonb, -- lo escribe una pasada, lo lee la ingesta por su caché
has_server boolean NOT NULL DEFAULT false,-- ¿este proyecto ha enviado eventos del servidor alguna vez?
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE ingest_keys (
id text PRIMARY KEY, -- key_…
project_id text NOT NULL REFERENCES projects ON DELETE CASCADE,
key text NOT NULL UNIQUE, -- spk_…: pública por diseño, se guarda tal cual
allowed_origins text[] NOT NULL DEFAULT '{}',-- vacío = cualquier origen
rate_limit_per_minute integer NOT NULL DEFAULT 600,
revoked_at timestamptz
);
CREATE TABLE api_tokens (
id text PRIMARY KEY, -- tok_…
project_id text NOT NULL REFERENCES projects ON DELETE CASCADE,
name text NOT NULL,
token_hash bytea NOT NULL UNIQUE, -- sha256(sps_…). El token se muestra una vez y nunca se guarda.
scopes text[] NOT NULL CHECK (scopes <@ ARRAY['read', 'replay', 'admin']),
revoked_at timestamptz
);No hay tabla users ni tabla organizations. Esas son de la parte privada de Sypnia Cloud Nube, en una base de datos propia. El motor conoce proyectos, llaves y tokens, y un token raíz que vive en su configuración, nunca en una tabla.
El registro
Tres tablas pequeñas hacen que cada paso se pueda repetir sin daño. Agregación explica cómo se usan.
-- Una fila por objeto de segmento. La escribe la ingesta cuando el objeto ya existe.
CREATE TABLE segments (
project_id text NOT NULL,
key text NOT NULL,
environment text NOT NULL,
hour timestamptz NOT NULL, -- el hr= de la llave
events integer NOT NULL,
bytes integer NOT NULL,
batch_ids text[] NOT NULL, -- los lotes que contiene
skipped text[] NOT NULL DEFAULT '{}', -- de esos, los que ya traía un segmento anterior
leased_until timestamptz, -- un worker lo está revisando
scanned_at timestamptz, -- la vía rápida ya terminó con él
rolled_at timestamptz, -- la consolidación ya lo sumó a los contadores
PRIMARY KEY (project_id, key)
);
CREATE INDEX segments_unscanned ON segments (key) WHERE scanned_at IS NULL;
CREATE INDEX segments_by_hour ON segments (project_id, environment, hour);
-- Una fila por lote durante 48 horas: así un lote que llega dos veces se cuenta una.
CREATE TABLE ingest_batches (
project_id text NOT NULL,
batch_id text NOT NULL,
segment text NOT NULL,
seen_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (project_id, batch_id)
);
-- Una fila por proyecto, entorno y hora: el control de corridas de la consolidación.
CREATE TABLE hours (
project_id text NOT NULL,
environment text NOT NULL,
hour timestamptz NOT NULL,
status text NOT NULL CHECK (status IN ('open', 'running', 'failed', 'closed')),
events integer NOT NULL DEFAULT 0,
last_run_at timestamptz,
error text,
PRIMARY KEY (project_id, environment, hour)
);Problemas
CREATE TABLE problems (
id text PRIMARY KEY, -- prb_…
project_id text NOT NULL REFERENCES projects ON DELETE CASCADE,
environment text NOT NULL,
fingerprint text NOT NULL CHECK (fingerprint ~ '^[0-9a-f]{16}$'),
slug text NOT NULL,
old_slugs text[] NOT NULL DEFAULT '{}', -- todo slug que tuvo sigue funcionando
kind text NOT NULL CHECK (kind IN ('error', 'failed_call', 'timeout')),
origin text NOT NULL CHECK (origin IN ('browser', 'server')),
status text NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'resolved', 'ignored')),
regressed boolean NOT NULL DEFAULT false,
title text NOT NULL, -- el título técnico, como se vio la primera vez
route text,
first_seen timestamptz NOT NULL,
last_seen timestamptz NOT NULL,
first_release text,
last_release text,
occurrences bigint NOT NULL DEFAULT 0,
people integer NOT NULL DEFAULT 0, -- filas de problem_hits con kind 'person'
sessions integer NOT NULL DEFAULT 0, -- filas de problem_hits con kind 'session'
people_at_last_alert integer NOT NULL DEFAULT 0, -- contra qué se mide «creciendo»
growing_until timestamptz,
resolved_at timestamptz,
resolved_by text,
resolved_in_release text,
note text,
sample jsonb, -- una ocurrencia completa: mensaje, pila, pila original, id de traza
analysis jsonb, -- la última respuesta del agente, como la devuelve la API
created_at timestamptz NOT NULL DEFAULT now(),
UNIQUE (project_id, environment, fingerprint),
UNIQUE (project_id, slug)
);
-- Ocurrencias por hora, para la línea de tiempo. Los arreglos se limitan a 200, como en el sistema del que sale.
CREATE TABLE problem_occurrences (
project_id text NOT NULL,
problem_id text NOT NULL REFERENCES problems ON DELETE CASCADE,
hour timestamptz NOT NULL,
occurrences integer NOT NULL,
person_keys text[] NOT NULL DEFAULT '{}',
session_ids text[] NOT NULL DEFAULT '{}',
people integer NOT NULL DEFAULT 0, -- GREATEST(stored, cardinality(person_keys))
sessions integer NOT NULL DEFAULT 0,
PRIMARY KEY (project_id, problem_id, hour)
);
-- A quién y a qué sesiones afectó un problema, una vez cada una. Esto hace exacto el «3 personas».
CREATE TABLE problem_hits (
project_id text NOT NULL,
problem_id text NOT NULL REFERENCES problems ON DELETE CASCADE,
kind text NOT NULL CHECK (kind IN ('person', 'session')),
key text NOT NULL, -- id de persona, o `device:<did>` para alguien nunca identificado; o el id de sesión
first_seen timestamptz NOT NULL,
last_seen timestamptz NOT NULL,
PRIMARY KEY (project_id, problem_id, kind, key)
);people no es una estimación. Cada persona a la que afecta un problema es una fila en problem_hits; la inserción usa ON CONFLICT DO NOTHING, y el número de filas que de verdad insertó se suma a problems.people. La misma persona fallando dos veces no suma nada. Las filas de sesión expiran con la sesión; las de persona duran lo que dure el problema, así que el conteo nunca baja.
Números
Las tablas por hora guardan un histograma por métrica en vez de los valores. Un histograma es un arreglo de contadores con límites fijos, así que dos se unen sumando posición por posición, y un percentil se lee del arreglo cuando lo pides. Agregación tiene los límites y la función.
CREATE TABLE perf_pages_hourly (
project_id text NOT NULL,
environment text NOT NULL,
hour timestamptz NOT NULL,
route text NOT NULL,
device text NOT NULL, -- mobile | tablet | desktop
views integer NOT NULL DEFAULT 0,
sessions integer NOT NULL DEFAULT 0, -- sesiones distintas en la hora: exacto, porque la hora se relee completa
errors integer NOT NULL DEFAULT 0,
rage_clicks integer NOT NULL DEFAULT 0,
dead_clicks integer NOT NULL DEFAULT 0,
lcp_hist integer[] NOT NULL, -- 15 celdas, milisegundos
inp_hist integer[] NOT NULL, -- 15 celdas
ttfb_hist integer[] NOT NULL, -- 15 celdas
cls_hist integer[] NOT NULL, -- 10 celdas
PRIMARY KEY (project_id, environment, hour, route, device)
) PARTITION BY RANGE (hour);
CREATE TABLE perf_api_hourly (
project_id text NOT NULL,
environment text NOT NULL,
hour timestamptz NOT NULL,
method text NOT NULL,
route text NOT NULL,
requests integer NOT NULL DEFAULT 0, -- como las vio el navegador
ok integer NOT NULL DEFAULT 0, -- 200 a 399
rejected integer NOT NULL DEFAULT 0, -- 401, 403, 404, 409, 422 y los demás 4xx que no son fallas
failed integer NOT NULL DEFAULT 0, -- sin respuesta, 400, 500 o más
dur_hist integer[] NOT NULL,
server_requests integer NOT NULL DEFAULT 0, -- como las vio el servidor
server_failed integer NOT NULL DEFAULT 0,
timeouts integer NOT NULL DEFAULT 0,
db_calls integer NOT NULL DEFAULT 0,
db_ms bigint NOT NULL DEFAULT 0,
server_dur_hist integer[] NOT NULL,
PRIMARY KEY (project_id, environment, hour, method, route)
) PARTITION BY RANGE (hour);
-- El índice de trazas. Los spans se quedan en el bucket: `segment` dice qué objeto los tiene.
CREATE TABLE traces (
project_id text NOT NULL,
trace_id text NOT NULL, -- 32 hex, un id de traza W3C
started_at timestamptz NOT NULL,
environment text NOT NULL,
service text,
method text,
route text,
status integer,
duration_ms integer NOT NULL,
spans integer NOT NULL DEFAULT 0,
failed boolean NOT NULL DEFAULT false,
partial boolean NOT NULL DEFAULT false, -- un registro completo reemplaza a uno parcial
sid text,
problem_id text,
segment text NOT NULL,
PRIMARY KEY (project_id, started_at, trace_id)
) PARTITION BY RANGE (started_at);El índice de sesiones es una fila por sesión, que se ensancha a medida que llega más de la sesión:
CREATE TABLE sessions (
project_id text NOT NULL,
sid text NOT NULL, -- 32 hex, lo elige el SDK
environment text NOT NULL,
started_at timestamptz NOT NULL,
ended_at timestamptz NOT NULL,
person_id text,
account_id text,
device_id text,
release text,
device text,
browser text,
os text,
locale text,
entry_route text,
routes text[] NOT NULL DEFAULT '{}', -- en orden de primera visita, máximo 50
page_views integer NOT NULL DEFAULT 0,
clicks integer NOT NULL DEFAULT 0,
rage_clicks integer NOT NULL DEFAULT 0,
dead_clicks integer NOT NULL DEFAULT 0,
errors integer NOT NULL DEFAULT 0,
requests integer NOT NULL DEFAULT 0,
failed_requests integer NOT NULL DEFAULT 0,
has_replay boolean NOT NULL DEFAULT false,
PRIMARY KEY (project_id, sid)
);
CREATE INDEX sessions_recent ON sessions (project_id, environment, ended_at DESC);
CREATE INDEX sessions_person ON sessions (project_id, person_id, ended_at DESC) WHERE person_id IS NOT NULL;
CREATE INDEX sessions_trouble ON sessions (project_id, environment, ended_at DESC)
WHERE errors > 0 OR rage_clicks > 0 OR dead_clicks > 0 OR failed_requests > 0;Disponibilidad, alertas, uso
CREATE TABLE uptime_results (
project_id text NOT NULL,
check_id text NOT NULL, -- chk_…
at timestamptz NOT NULL,
ok boolean NOT NULL,
status integer, -- el estado HTTP, null cuando no hubo respuesta
ms integer,
reason text,
PRIMARY KEY (project_id, check_id, at)
) PARTITION BY RANGE (at);
CREATE TABLE alerts (
id text PRIMARY KEY, -- alt_…
project_id text NOT NULL REFERENCES projects ON DELETE CASCADE,
environment text NOT NULL,
kind text NOT NULL, -- problem.new, problem.regressed, problem.growing, uptime.down, …
subject_type text NOT NULL,
subject_id text NOT NULL,
dedupe_key text NOT NULL, -- una alerta por causa: `problem.new:prb_8f3k2m9x4q7w`
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
release_by timestamptz NOT NULL, -- el último momento en que puede salir
released_at timestamptz, -- null mientras espera la frase del agente
acknowledged_at timestamptz,
acknowledged_by text,
UNIQUE (project_id, dedupe_key)
);
-- Lo que usó un proyecto, por día. Lo escribe la consolidación, lo leen las cuotas y GET /v1/usage.
CREATE TABLE usage_daily (
project_id text NOT NULL,
day date NOT NULL,
events bigint NOT NULL DEFAULT 0, -- eventos contados: errores, trazas, muestras de rendimiento
events_all bigint NOT NULL DEFAULT 0, -- todos los eventos guardados, contados o no
replays integer NOT NULL DEFAULT 0, -- sesiones con grabación
analyses integer NOT NULL DEFAULT 0,
dropped_over_limit bigint NOT NULL DEFAULT 0,
PRIMARY KEY (project_id, day)
);Las demás tablas siguen los mismos patrones y están en las migraciones: people y accounts (los nombres y correos que tu app envió con identify()), releases, clicks_daily, click_elements_daily, vital_elements_daily, custom_events_daily, form_failures_daily, uptime_checks, alert_rules, webhooks, webhook_deliveries, analyses, trace_failures, held_failures, suggestions.
Particiones y retención
Leer este diagrama como texto
Una barra por tipo de dato sobre un eje de días que no está a escala. En Postgres: ingest_batches (el control de duplicados), 2 días; los números por hora y por día, 400 días (retention.numbers_days); los problemas, con su frase, estado y conteos diarios, mientras exista el proyecto. En el Bucket: fragmentos de grabación, 30 días (retention.replays_days); eventos crudos en segmentos, 90 días (retention.events_days); archivos por sesión e índice de sesiones, 90 días; capturas de página, 90 días (retention.snapshots_days); Parquet, 90 días; source maps, 90 días desde la última vez que se vio la versión (retention.sourcemaps_days).
Particiones. Las tablas que crecen con el tiempo y se leen por tiempo se particionan por mes: perf_pages_hourly, perf_api_hourly, traces, uptime_results y las tablas diarias de clics. La tarea diaria crea las particiones de los dos meses siguientes y elimina las más viejas que retention.numbers_days. Eliminar una partición es instantáneo y no deja nada que limpiar.
El motor crea las particiones por su cuenta, en SQL simple, y no necesita ninguna extensión. La alternativa era pg_partman o pg_cron, que muchos servicios de Postgres administrado no ofrecen. sessions y problems no se particionan: se actualizan por llave, y una llave de partición dentro de su llave primaria obligaría a cada upsert a nombrar una fecha.
Retención. Una tarea al día, por proyecto:
| Dato | Cómo se elimina |
|---|---|
| Segmentos, Parquet, capturas | Se listan y borran carpetas dt= completas más viejas que el límite. |
| Archivos por sesión, fragmentos de grabación | La tarea lee las filas vencidas de sessions, borra las dos carpetas de cada sid y luego la fila. Para grabaciones que pasaron su propio límite, más corto, borra los fragmentos y pone has_replay en false. |
| Source maps | Las versiones que no se ven hace 90 días pierden su carpeta. |
| Números por hora y por día | Se eliminan las particiones viejas. |
ingest_batches, filas viejas del registro, entregas de webhook ya hechas | Se borran por edad. |
| Problemas | Nunca, mientras exista el proyecto. Su ocurrencia de ejemplo pierde el enlace a la sesión cuando la sesión expira. |
La tarea borra listando porque la retención es una regla del motor, no del almacenamiento. Funciona igual en Amazon S3, Cloudflare R2 y MinIO, y le permite a Sypnia Cloud darle a cada plan su propio número de días Nube. En AWS puedes agregar una regla de ciclo de vida como segunda protección; la plantilla agrega una solo para subidas sin terminar.
Cuánto pesa un millón de eventos
Son estimaciones. La primera fila usa una cifra medida en el sistema del que sale este motor: unos 16 MB de NDJSON con gzip al día para 110 a 150 mil registros diarios.
| Dato | Aritmética | Por millón de eventos |
|---|---|---|
| Segmentos | 16 MB ÷ 130.000 registros ≈ 123 bytes por evento, comprimido | ≈ 125 MB |
| Archivos por sesión | Los mismos eventos otra vez, agrupados por sesión; los registros del servidor sin sesión quedan fuera | ≤ 125 MB |
| Parquet | Sin medir. Los archivos por columnas con ZSTD suelen ser más pequeños que JSON con gzip; presupuestamos el mismo tamaño hasta medirlo | ≤ 125 MB |
| Fragmentos de grabación | Medido allá: una sesión grabada corta son 22 fragmentos, 751 KB. Unas 7.700 sesiones por millón de eventos (1.000 sesiones al día con 130.000 registros). Con 10 % grabado desde el inicio y toda sesión con problemas, presupuesta 15 %: 1.150 sesiones × 0,75 MB | ≈ 870 MB |
| Capturas de página | Medido allá: 70 a 107 KB cada una. Crecen con las rutas, no con los eventos | unos MB |
| Bucket, total | ≈ 1,2 GB, casi todo grabaciones | |
sessions | 7.700 filas × unos 600 bytes, el doble con índices | ≈ 10 MB |
| Números por hora | Crecen con las rutas, no con los eventos: 100 rutas × 3 dispositivos × 24 horas × unos 400 bytes | ≈ 3 MB al día, con cualquier tráfico |
ingest_batches | Unos 230.000 lotes (30 lotes por sesión) × unos 120 bytes, por 48 horas | ≈ 28 MB, temporal |
| Problemas y lo demás | Miles de filas como mucho | menos de 5 MB |
| Postgres, total | ≈ 20 MB que se quedan, más ≈ 30 MB temporales |
Dos cosas pueden romper estos números, y las dos tienen tope. Una sesión larga puede grabar hasta 720 fragmentos de 200 KB, 144 MB; medido allá, una grabación llegó a 158 MB antes de que existiera el tope. Y los source maps van por versión, no por evento: medido allá, un despliegue de una app grande son 965 mapas y 109 MB.
Con 1,2 GB por millón de eventos, 90 días de un proyecto que envía un millón de eventos al mes son unos 3,6 GB en el bucket. El almacenamiento no es lo que paga un despliegue. Las escrituras sí: Formas de despliegue tiene esa aritmética.
Qué nunca se guarda
| Nunca se guarda | Porque |
|---|---|
| Lo que una persona escribe | El SDK lo enmascara antes de que nada salga del navegador. El motor nunca lo recibe. |
| Cuerpos de solicitudes y respuestas, cookies, encabezados, cadenas de consulta, fragmentos de URL | Ningún evento tiene un campo para eso. url es una ruta. |
| Direcciones IP con los eventos | La ingesta usa la dirección para el límite de velocidad, en memoria, y no la escribe en un evento, un objeto ni una fila. No hay geolocalización. |
| Eventos crudos en Postgres | Regla 1 del resumen. |
| Contenido de grabaciones en Postgres | Una fila de sesión tiene has_replay y nada más sobre la grabación. |
| Un token de API, el token raíz, la llave de IA o el secreto de un webhook en texto plano | Los tokens se guardan como hash SHA-256; los demás viven en la configuración y nunca se imprimen, se registran ni se devuelven. |
| Atributos de spans que parecen secretos | Los atributos cuyo nombre contiene authorization, cookie, password, secret o token se quitan en la ingesta. |
| Lo que se envió al modelo | El motor guarda el análisis y sus conteos de tokens, no el contexto. Se puede rearmar a pedido con GET /v1/problems/{problem}/context. |
Los nombres y correos se guardan solo cuando tu app los envía con identify(). Viven en people y accounts, y se borran con DELETE /v1/people/{person_id}. Mira Qué se recopila.
Sigue
- Cómo se escribe un segmento.
- Cómo se llenan las tablas de números y qué protege el registro.
- Cuánto cuesta este almacenamiento en AWS y en tu propio servidor.