@growconnect/growtickets-nest 0.1.0 → 0.3.0

package/dist/logs/format.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatArgs = formatArgs;
+exports.stringify = stringify;
+/**
+ * Cómo se escribe un valor o una lista de argumentos como lo haría `console.log`, sin `node:util`: así vale también donde no hay Node.
+ */
+const MAX_ARG = 2000;
+/** Lo que `console.log` haría con los argumentos: la sustitución estilo printf del primero (`%s`, `%d`, `%j`…) y el resto unido con espacios. */
+function formatArgs(args) {
+    if (args.length === 0)
+        return '';
+    const [primero, ...resto] = args;
+    if (typeof primero !== 'string' || !primero.includes('%'))
+        return args.map(stringify).join(' ');
+    let usados = 0;
+    const texto = primero.replace(/%([sdifjoOc%])/g, (coincidencia, tipo) => {
+        if (tipo === '%')
+            return '%';
+        if (usados >= resto.length)
+            return coincidencia;
+        const valor = resto[usados++];
+        switch (tipo) {
+            case 's':
+                return typeof valor === 'string' ? valor : stringify(valor);
+            case 'd':
+            case 'i':
+                return String(Number.parseInt(String(valor), 10));
+            case 'f':
+                return String(Number.parseFloat(String(valor)));
+            case 'c':
+                return '';
+            default:
+                return stringify(valor);
+        }
+    });
+    return [texto, ...resto.slice(usados).map(stringify)].join(' ');
+}
+/** Un valor como texto, sin ejecutar nada suyo: un `Error` como `Clase: mensaje`, un objeto como JSON (acotado y sin ciclos). */
+function stringify(valor) {
+    switch (typeof valor) {
+        case 'string':
+            return valor;
+        case 'undefined':
+            return 'undefined';
+        case 'function':
+            return `[Function${valor.name ? `: ${valor.name}` : ''}]`;
+        case 'symbol':
+            return valor.toString();
+        case 'object':
+            break;
+        default:
+            return String(valor);
+    }
+    if (valor === null)
+        return 'null';
+    if (valor instanceof Error)
+        return `${valor.name}: ${valor.message}`;
+    const vistos = new WeakSet();
+    try {
+        const json = JSON.stringify(valor, (_clave, v) => {
+            if (typeof v === 'bigint')
+                return v.toString();
+            if (v !== null && typeof v === 'object') {
+                if (vistos.has(v))
+                    return '[circular]';
+                vistos.add(v);
+            }
+            return v;
+        });
+        return json.length > MAX_ARG ? `${json.slice(0, MAX_ARG)}…` : json;
+    }
+    catch {
+        return '[object]';
+    }
+}

package/dist/logs/levels.d.ts

@@ -0,0 +1,12 @@
+import type { LogLevel } from './types';
+export declare const LEVELS: readonly LogLevel[];
+/** Un número de nivel de pino (10 trace, 20 debug, 30 info, 40 warn, 50 error, 60 fatal) llevado al nivel de PSR-3 que lo contiene. */
+export declare function levelFromNumber(valor: number): LogLevel;
+/**
+ * Cualquier nombre corriente de nivel (`warn`, `fatal`, `verbose`, `CRITICAL`) o un número de pino, llevado a uno de los ocho. Lo que no
+ * se reconoce da `null`: inventar un nivel dejaría la línea donde nadie la busca.
+ */
+export declare function normalizeLevel(entrada: unknown): LogLevel | null;
+export declare function levelRank(nivel: LogLevel): number;
+/** `warning` o peor: lo que nunca se muestrea ni se descarta primero, y lo que la central agrupa en errores repetidos. */
+export declare function isSevere(nivel: LogLevel): boolean;

package/dist/logs/levels.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEVELS = void 0;
+exports.levelFromNumber = levelFromNumber;
+exports.normalizeLevel = normalizeLevel;
+exports.levelRank = levelRank;
+exports.isSevere = isSevere;
+exports.LEVELS = ['debug', 'info', 'notice', 'warning', 'error', 'critical', 'alert', 'emergency'];
+const ALIASES = {
+    trace: 'debug',
+    verbose: 'debug',
+    log: 'info',
+    information: 'info',
+    warn: 'warning',
+    err: 'error',
+    crit: 'critical',
+    fatal: 'critical',
+    emerg: 'emergency',
+    panic: 'emergency',
+};
+/** Un número de nivel de pino (10 trace, 20 debug, 30 info, 40 warn, 50 error, 60 fatal) llevado al nivel de PSR-3 que lo contiene. */
+function levelFromNumber(valor) {
+    if (!Number.isFinite(valor))
+        return 'info';
+    if (valor <= 20)
+        return 'debug';
+    if (valor <= 30)
+        return 'info';
+    if (valor <= 40)
+        return 'warning';
+    if (valor <= 50)
+        return 'error';
+    return 'critical';
+}
+/**
+ * Cualquier nombre corriente de nivel (`warn`, `fatal`, `verbose`, `CRITICAL`) o un número de pino, llevado a uno de los ocho. Lo que no
+ * se reconoce da `null`: inventar un nivel dejaría la línea donde nadie la busca.
+ */
+function normalizeLevel(entrada) {
+    if (typeof entrada === 'number')
+        return levelFromNumber(entrada);
+    if (typeof entrada !== 'string')
+        return null;
+    const nombre = entrada.trim().toLowerCase();
+    if (exports.LEVELS.includes(nombre))
+        return nombre;
+    return ALIASES[nombre] ?? null;
+}
+function levelRank(nivel) {
+    return exports.LEVELS.indexOf(nivel);
+}
+/** `warning` o peor: lo que nunca se muestrea ni se descarta primero, y lo que la central agrupa en errores repetidos. */
+function isSevere(nivel) {
+    return levelRank(nivel) >= levelRank('warning');
+}

package/dist/logs/monitor.d.ts

@@ -0,0 +1,92 @@
+import { type FlushResult } from './flusher';
+import { type Transport } from './sender';
+import { type LogSettings } from './settings';
+import type { LogRecord, LogsHost } from './types';
+/** Cada cuánto se envía lo acumulado. */
+export declare const FLUSH_INTERVAL_MS = 60000;
+/**
+ * Cuánto se espera, como mucho, para mandar una línea grave (`warning` o peor): un proceso que se cae o al que le llega un `SIGTERM` no deja
+ * tiempo de mandar el último minuto, y lo que más hace falta tener es justo el error de antes de morir. Una ráfaga de errores no manda un
+ * lote por línea: el aviso se agrupa en este margen.
+ */
+export declare const URGENT_FLUSH_MS = 5000;
+export interface MonitorOptions {
+    now?: () => number;
+    flushIntervalMs?: number;
+    /** Cuánto se espera para mandar una línea grave. De serie, `URGENT_FLUSH_MS`. */
+    urgentFlushMs?: number;
+    transport?: Transport;
+    random?: () => number;
+    /** Dónde se escribe un aviso de la propia librería. De serie, el error estándar: NUNCA la consola, que otros adaptadores capturan. */
+    warn?: (mensaje: string) => void;
+}
+/**
+ * La puerta de los logs de UN proceso: recibe cada línea que entrega un adaptador, la tapa, la acota, la muestrea y la deja en la
+ * cola para mandarla a la mesa de ayuda cada minuto.
+ *
+ * ## Capturar nunca tumba nada
+ *
+ * - **A prueba de reentrada.** La propia librería (o un `console` parcheado) puede escribir mientras captura; sin la guarda cada línea
+ *   suya dispararía otra captura. Lo que llega mientras se captura se ignora.
+ * - **No lanza.** Una excepción aquí se traga: el peor fallo permitido es perder una línea, nunca romper la petición que casualmente
+ *   escribió en el log.
+ * - **No espera.** Capturar es síncrono y barato; el envío es de un temporizador que no retiene el proceso (`unref`).
+ *
+ * ## Lo grave no espera al minuto
+ *
+ * Una línea `warning` o peor programa un envío a los 5 segundos (agrupando las que lleguen en ese margen): si el proceso muere —un fallo, un
+ * `SIGTERM` de un despliegue— se pierden a lo sumo esos segundos y no el último minuto, justo donde está el error que importa.
+ *
+ * ## El muestreo no toca lo importante
+ *
+ * Por encima de `sample_cap` líneas por minuto se guarda 1 de cada N con peso N —lo leve: `debug`, `info`, `notice`—; un `warning` o
+ * peor se guarda SIEMPRE, con peso 1: un bucle de `debug` no puede esconder el error que de verdad hay que ver.
+ *
+ * ## Sin clave no hay nada
+ *
+ * Si el entorno no trae la dirección y la clave (o el módulo está apagado con `GROWTICKETS_LOGS=false`) no se acumula ni se envía nada,
+ * y no se lanza ni un aviso por línea: se avisa UNA vez por el error estándar.
+ */
+export declare class LogMonitor {
+    private readonly host;
+    private readonly opciones;
+    private readonly buffer;
+    private readonly remote;
+    private readonly flusher;
+    private readonly sampler;
+    private readonly redactor;
+    private readonly transport;
+    private readonly ahora;
+    private readonly avisos;
+    private ajustes;
+    private temporizador;
+    private urgente;
+    private ocupado;
+    private apagando;
+    constructor(host: LogsHost, opciones?: MonitorOptions);
+    settings(): LogSettings;
+    /** Recibe una línea. No lanza, no espera y no hace nada si los logs están apagados o el entorno no está completo. */
+    capture(registro: LogRecord): void;
+    /** Arranca el envío periódico. Varias llamadas son una. El temporizador no retiene el proceso. */
+    start(): void;
+    /** Manda lo acumulado dentro de unos segundos si no hay ya un envío urgente en camino. El reloj no retiene el proceso. */
+    private scheduleUrgent;
+    /** Envía ya lo acumulado. `force` se salta el corte tras fallos. Nunca lanza. */
+    flush(force?: boolean): Promise<FlushResult>;
+    /** Para el temporizador y manda lo último, esperando como mucho tres segundos. Lo llama el adaptador al cerrar la app. */
+    shutdown(): Promise<void>;
+    /** Lo que hay sin enviar. Lo usan las pruebas y `doctor`. */
+    pending(): number;
+    private env;
+    private warn;
+}
+/**
+ * El monitor de ESTE proceso. Vive en `globalThis` porque un empaquetador puede cargar esta librería una vez por ruta, y cada copia
+ * tendría su cola y su temporizador: con uno solo, una línea se manda una vez.
+ *
+ * Al crearlo se engancha, una sola vez por proceso, a `beforeExit` —cuando el bucle de eventos se vacía, por ejemplo tras `app.close()`—
+ * para mandar lo último. NO se engancha a ninguna señal (`SIGTERM`, `SIGINT`): quien lo hace cambia lo que el proceso hace al recibirla.
+ */
+export declare function logMonitor(host?: LogsHost, opciones?: MonitorOptions): LogMonitor | null;
+/** Sólo las pruebas: olvida el monitor del proceso. */
+export declare function resetLogMonitor(): void;

package/dist/logs/monitor.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogMonitor = exports.URGENT_FLUSH_MS = exports.FLUSH_INTERVAL_MS = void 0;
+exports.logMonitor = logMonitor;
+exports.resetLogMonitor = resetLogMonitor;
+const buffer_1 = require("./buffer");
+const entry_builder_1 = require("./entry-builder");
+const flusher_1 = require("./flusher");
+const levels_1 = require("./levels");
+const redactor_1 = require("./redactor");
+const remote_config_1 = require("./remote-config");
+const runtime_1 = require("./runtime");
+const sampler_1 = require("./sampler");
+const sender_1 = require("./sender");
+const settings_1 = require("./settings");
+/** Cada cuánto se envía lo acumulado. */
+exports.FLUSH_INTERVAL_MS = 60_000;
+/**
+ * Cuánto se espera, como mucho, para mandar una línea grave (`warning` o peor): un proceso que se cae o al que le llega un `SIGTERM` no deja
+ * tiempo de mandar el último minuto, y lo que más hace falta tener es justo el error de antes de morir. Una ráfaga de errores no manda un
+ * lote por línea: el aviso se agrupa en este margen.
+ */
+exports.URGENT_FLUSH_MS = 5000;
+/** Lo más que se espera al enviar lo último, al apagar: el proceso se está yendo y no puede quedarse esperando a una mesa de ayuda caída. */
+const SHUTDOWN_MS = 3000;
+/** Cuánto vive la lectura de los interruptores: capturar corre en cada línea y no relee el entorno cada vez. */
+const SETTINGS_TTL_MS = 5000;
+const WARN_EVERY_MS = 3_600_000;
+/**
+ * La puerta de los logs de UN proceso: recibe cada línea que entrega un adaptador, la tapa, la acota, la muestrea y la deja en la
+ * cola para mandarla a la mesa de ayuda cada minuto.
+ *
+ * ## Capturar nunca tumba nada
+ *
+ * - **A prueba de reentrada.** La propia librería (o un `console` parcheado) puede escribir mientras captura; sin la guarda cada línea
+ *   suya dispararía otra captura. Lo que llega mientras se captura se ignora.
+ * - **No lanza.** Una excepción aquí se traga: el peor fallo permitido es perder una línea, nunca romper la petición que casualmente
+ *   escribió en el log.
+ * - **No espera.** Capturar es síncrono y barato; el envío es de un temporizador que no retiene el proceso (`unref`).
+ *
+ * ## Lo grave no espera al minuto
+ *
+ * Una línea `warning` o peor programa un envío a los 5 segundos (agrupando las que lleguen en ese margen): si el proceso muere —un fallo, un
+ * `SIGTERM` de un despliegue— se pierden a lo sumo esos segundos y no el último minuto, justo donde está el error que importa.
+ *
+ * ## El muestreo no toca lo importante
+ *
+ * Por encima de `sample_cap` líneas por minuto se guarda 1 de cada N con peso N —lo leve: `debug`, `info`, `notice`—; un `warning` o
+ * peor se guarda SIEMPRE, con peso 1: un bucle de `debug` no puede esconder el error que de verdad hay que ver.
+ *
+ * ## Sin clave no hay nada
+ *
+ * Si el entorno no trae la dirección y la clave (o el módulo está apagado con `GROWTICKETS_LOGS=false`) no se acumula ni se envía nada,
+ * y no se lanza ni un aviso por línea: se avisa UNA vez por el error estándar.
+ */
+class LogMonitor {
+    constructor(host, opciones = {}) {
+        this.host = host;
+        this.opciones = opciones;
+        this.sampler = new sampler_1.MinuteSampler();
+        this.avisos = new Map();
+        this.ajustes = null;
+        this.temporizador = null;
+        this.urgente = null;
+        this.ocupado = false;
+        this.apagando = false;
+        this.ahora = opciones.now ?? Date.now;
+        this.transport = opciones.transport ?? (0, sender_1.createTransport)(host);
+        this.buffer = new buffer_1.LogBuffer(10_000, this.ahora);
+        this.remote = new remote_config_1.RemoteConfig(this.transport, this.ahora);
+        this.redactor = new redactor_1.Redactor(() => this.env(), () => this.settings().redactKeys, this.ahora);
+        this.flusher = new flusher_1.Flusher({
+            host,
+            transport: this.transport,
+            remote: this.remote,
+            buffer: this.buffer,
+            settings: () => this.settings(),
+            warn: (clave, mensaje) => this.warn(clave, mensaje),
+            now: this.ahora,
+        });
+    }
+    settings() {
+        const ahora = this.ahora();
+        if (!this.ajustes || ahora - this.ajustes.leidosEn >= SETTINGS_TTL_MS) {
+            this.ajustes = { valor: (0, settings_1.readLogSettings)(this.env()), leidosEn: ahora };
+        }
+        return this.ajustes.valor;
+    }
+    /** Recibe una línea. No lanza, no espera y no hace nada si los logs están apagados o el entorno no está completo. */
+    capture(registro) {
+        if (this.ocupado)
+            return;
+        this.ocupado = true;
+        try {
+            const ajustes = this.settings();
+            if (!ajustes.enabled)
+                return;
+            if (!this.host.target()) {
+                this.warn('sin-entorno', 'GrowTickets logs: faltan GROWTICKETS_URL o GROWTICKETS_API_KEY (o no son válidas): no se manda ninguna línea.');
+                return;
+            }
+            if ((0, levels_1.levelRank)(registro.level) < (0, levels_1.levelRank)(ajustes.minLevel))
+                return;
+            if (this.remote.enabled() === null)
+                void this.remote.refreshIfStale();
+            if (this.remote.enabled() === false)
+                return;
+            const grave = (0, levels_1.isSevere)(registro.level);
+            const peso = grave ? 1 : this.sampler.weight(this.ahora(), this.remote.sampleCap());
+            if (!(0, sampler_1.keep)(peso, this.opciones.random))
+                return;
+            const entrada = (0, entry_builder_1.buildEntry)(registro, { limits: this.remote.limits(), redactor: this.redactor, root: (0, runtime_1.currentDir)() });
+            if (peso > 1)
+                entrada.weight = peso;
+            this.buffer.add(entrada, grave);
+            this.start();
+            if (grave)
+                this.scheduleUrgent();
+        }
+        catch {
+            return;
+        }
+        finally {
+            this.ocupado = false;
+        }
+    }
+    /** Arranca el envío periódico. Varias llamadas son una. El temporizador no retiene el proceso. */
+    start() {
+        this.apagando = false;
+        if (this.temporizador)
+            return;
+        const reloj = setInterval(() => {
+            void this.flush();
+        }, this.opciones.flushIntervalMs ?? exports.FLUSH_INTERVAL_MS);
+        reloj.unref?.();
+        this.temporizador = reloj;
+    }
+    /** Manda lo acumulado dentro de unos segundos si no hay ya un envío urgente en camino. El reloj no retiene el proceso. */
+    scheduleUrgent() {
+        if (this.urgente)
+            return;
+        const reloj = setTimeout(() => {
+            this.urgente = null;
+            void this.flush();
+        }, this.opciones.urgentFlushMs ?? exports.URGENT_FLUSH_MS);
+        reloj.unref?.();
+        this.urgente = reloj;
+    }
+    /** Envía ya lo acumulado. `force` se salta el corte tras fallos. Nunca lanza. */
+    flush(force = false) {
+        return this.flusher.flush({ force });
+    }
+    /** Para el temporizador y manda lo último, esperando como mucho tres segundos. Lo llama el adaptador al cerrar la app. */
+    async shutdown() {
+        if (this.apagando)
+            return;
+        this.apagando = true;
+        if (this.temporizador) {
+            clearInterval(this.temporizador);
+            this.temporizador = null;
+        }
+        if (this.urgente) {
+            clearTimeout(this.urgente);
+            this.urgente = null;
+        }
+        let limite;
+        const agotado = new Promise((resolver) => {
+            limite = setTimeout(resolver, SHUTDOWN_MS);
+            limite.unref?.();
+        });
+        try {
+            await Promise.race([this.flusher.flush({ final: true }), agotado]);
+        }
+        finally {
+            clearTimeout(limite);
+        }
+    }
+    /** Lo que hay sin enviar. Lo usan las pruebas y `doctor`. */
+    pending() {
+        return this.buffer.size() + this.flusher.state().pendientes;
+    }
+    env() {
+        return this.host.env ? this.host.env() : ((0, runtime_1.proc)()?.env ?? {});
+    }
+    warn(clave, mensaje) {
+        const ahora = this.ahora();
+        const antes = this.avisos.get(clave);
+        if (antes !== undefined && ahora - antes < WARN_EVERY_MS)
+            return;
+        this.avisos.set(clave, ahora);
+        if (this.opciones.warn)
+            this.opciones.warn(mensaje);
+        else
+            (0, runtime_1.proc)()?.stderr?.write(`[growtickets] ${mensaje}\n`);
+    }
+}
+exports.LogMonitor = LogMonitor;
+const KEY = Symbol.for('growtickets.logs.monitor');
+const EXIT_KEY = Symbol.for('growtickets.logs.exit');
+/**
+ * El monitor de ESTE proceso. Vive en `globalThis` porque un empaquetador puede cargar esta librería una vez por ruta, y cada copia
+ * tendría su cola y su temporizador: con uno solo, una línea se manda una vez.
+ *
+ * Al crearlo se engancha, una sola vez por proceso, a `beforeExit` —cuando el bucle de eventos se vacía, por ejemplo tras `app.close()`—
+ * para mandar lo último. NO se engancha a ninguna señal (`SIGTERM`, `SIGINT`): quien lo hace cambia lo que el proceso hace al recibirla.
+ */
+function logMonitor(host, opciones) {
+    const global = globalThis;
+    if (!global[KEY] && host) {
+        global[KEY] = new LogMonitor(host, opciones);
+        if (!global[EXIT_KEY]) {
+            global[EXIT_KEY] = true;
+            (0, runtime_1.proc)()?.on?.('beforeExit', () => {
+                void global[KEY]?.shutdown();
+            });
+        }
+    }
+    return global[KEY] ?? null;
+}
+/** Sólo las pruebas: olvida el monitor del proceso. */
+function resetLogMonitor() {
+    const global = globalThis;
+    delete global[KEY];
+}

package/dist/logs/normalize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * El contexto de una línea convertido a algo que se pueda mandar por JSON SIN ejecutar nada del producto.
+ *
+ * - **Nunca se llama a un método ni a un getter del producto.** Un modelo, una conexión o un cliente HTTP en el contexto se convierte en
+ *   `[object Clase]`: `toJSON()` o un getter de cualquiera podría lanzar, tardar o volcar sus datos. De un objeto corriente sólo se leen
+ *   las propiedades de datos; un getter sale como `[getter]`.
+ * - Las fechas van en ISO, los `bigint` como texto, los `Buffer` y `Map`/`Set` como su tamaño, un `Error` como una línea
+ *   (`[exception Clase: mensaje]`) y un ciclo como `[circular]`.
+ * - Todo con tope: cinco niveles, cien elementos por nivel y 4.096 caracteres por texto.
+ *
+ * Devuelve `null` si no hay nada que mandar.
+ */
+export declare function safeContext(contexto: unknown): Record<string, unknown> | null;
+export declare function cutString(texto: string, max?: number): string;

package/dist/logs/normalize.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeContext = safeContext;
+exports.cutString = cutString;
+const MAX_DEPTH = 5;
+const MAX_ITEMS = 100;
+const MAX_STRING = 4096;
+const MAX_ERROR_MESSAGE = 200;
+/**
+ * El contexto de una línea convertido a algo que se pueda mandar por JSON SIN ejecutar nada del producto.
+ *
+ * - **Nunca se llama a un método ni a un getter del producto.** Un modelo, una conexión o un cliente HTTP en el contexto se convierte en
+ *   `[object Clase]`: `toJSON()` o un getter de cualquiera podría lanzar, tardar o volcar sus datos. De un objeto corriente sólo se leen
+ *   las propiedades de datos; un getter sale como `[getter]`.
+ * - Las fechas van en ISO, los `bigint` como texto, los `Buffer` y `Map`/`Set` como su tamaño, un `Error` como una línea
+ *   (`[exception Clase: mensaje]`) y un ciclo como `[circular]`.
+ * - Todo con tope: cinco niveles, cien elementos por nivel y 4.096 caracteres por texto.
+ *
+ * Devuelve `null` si no hay nada que mandar.
+ */
+function safeContext(contexto) {
+    if (contexto === null || typeof contexto !== 'object' || Array.isArray(contexto))
+        return null;
+    const salida = walkObject(contexto, 0, new WeakSet());
+    return Object.keys(salida).length > 0 ? salida : null;
+}
+function walkObject(objeto, profundidad, vistos) {
+    const salida = {};
+    let n = 0;
+    vistos.add(objeto);
+    for (const clave of Object.keys(objeto)) {
+        if (++n > MAX_ITEMS) {
+            salida['…'] = 'recortado';
+            break;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(objeto, clave);
+        if (!descriptor)
+            continue;
+        if (descriptor.get || descriptor.set) {
+            salida[clave] = '[getter]';
+            continue;
+        }
+        const valor = convert(descriptor.value, profundidad + 1, vistos);
+        if (valor !== undefined)
+            salida[clave] = valor;
+    }
+    vistos.delete(objeto);
+    return salida;
+}
+function convert(valor, profundidad, vistos) {
+    switch (typeof valor) {
+        case 'string':
+            return cutString(valor);
+        case 'number':
+            return Number.isFinite(valor) ? valor : String(valor);
+        case 'boolean':
+            return valor;
+        case 'bigint':
+            return valor.toString();
+        case 'undefined':
+            return undefined;
+        case 'function':
+            return '[function]';
+        case 'symbol':
+            return valor.toString();
+        default:
+            break;
+    }
+    if (valor === null)
+        return null;
+    const objeto = valor;
+    if (vistos.has(objeto))
+        return '[circular]';
+    if (objeto instanceof Date)
+        return Number.isNaN(objeto.getTime()) ? '[invalid date]' : objeto.toISOString();
+    if (objeto instanceof Error)
+        return `[exception ${cutString(String(objeto.name), 80)}: ${cutString(String(objeto.message), MAX_ERROR_MESSAGE)}]`;
+    if (typeof URL !== 'undefined' && objeto instanceof URL)
+        return cutString(objeto.href);
+    if (ArrayBuffer.isView(objeto))
+        return `[Buffer ${objeto.byteLength} bytes]`;
+    if (objeto instanceof ArrayBuffer)
+        return `[Buffer ${objeto.byteLength} bytes]`;
+    if (objeto instanceof Map)
+        return `[Map ${objeto.size}]`;
+    if (objeto instanceof Set)
+        return `[Set ${objeto.size}]`;
+    if (Array.isArray(objeto)) {
+        if (profundidad >= MAX_DEPTH)
+            return '[array]';
+        vistos.add(objeto);
+        const salida = [];
+        for (let i = 0; i < objeto.length && i < MAX_ITEMS; i++)
+            salida.push(convert(objeto[i], profundidad + 1, vistos) ?? null);
+        if (objeto.length > MAX_ITEMS)
+            salida.push('…');
+        vistos.delete(objeto);
+        return salida;
+    }
+    if (isPlain(objeto))
+        return profundidad >= MAX_DEPTH ? '[object]' : walkObject(objeto, profundidad, vistos);
+    return `[object ${constructorName(objeto)}]`;
+}
+function isPlain(objeto) {
+    const proto = Object.getPrototypeOf(objeto);
+    return proto === null || proto === Object.prototype;
+}
+function constructorName(objeto) {
+    const nombre = Object.getPrototypeOf(objeto)?.constructor?.name;
+    return typeof nombre === 'string' && nombre !== '' ? cutString(nombre, 80) : 'Object';
+}
+function cutString(texto, max = MAX_STRING) {
+    return texto.length > max ? `${texto.slice(0, max)}…` : texto;
+}

package/dist/logs/pino-line.d.ts

@@ -0,0 +1,13 @@
+import type { LogRecord } from './types';
+export interface PinoOptions {
+    /** Mandar también las líneas por petición de Fastify. */
+    requests: boolean;
+}
+/**
+ * Una línea de pino (un objeto JSON y un salto de línea) convertida en un registro. Devuelve `null` si no es una línea de pino o si es
+ * de las que no se mandan.
+ *
+ * El nivel numérico de pino (10 a 60) se lleva a uno de los ocho de PSR-3; `err` (el error ya serializado: `type`, `message`, `stack`)
+ * pasa a ser la excepción; `name` es el canal, y el resto de campos —`reqId`, `req`, `res`, lo que el producto añadió— es el contexto.
+ */
+export declare function recordFromPinoLine(linea: string, opciones: PinoOptions): LogRecord | null;

package/dist/logs/pino-line.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordFromPinoLine = recordFromPinoLine;
+const levels_1 = require("./levels");
+/** Lo que pino escribe en cada línea y no es contexto del producto. */
+const RESERVED = new Set(['level', 'time', 'pid', 'hostname', 'msg', 'message', 'err', 'error', 'v', 'name']);
+/** Las dos líneas que Fastify escribe por cada petición: sin pedirlo, llenarían la central de lo que ya tiene el proxy. */
+const REQUEST_LINES = new Set(['incoming request', 'request completed']);
+/**
+ * Una línea de pino (un objeto JSON y un salto de línea) convertida en un registro. Devuelve `null` si no es una línea de pino o si es
+ * de las que no se mandan.
+ *
+ * El nivel numérico de pino (10 a 60) se lleva a uno de los ocho de PSR-3; `err` (el error ya serializado: `type`, `message`, `stack`)
+ * pasa a ser la excepción; `name` es el canal, y el resto de campos —`reqId`, `req`, `res`, lo que el producto añadió— es el contexto.
+ */
+function recordFromPinoLine(linea, opciones) {
+    if (linea.charCodeAt(0) !== 123)
+        return null;
+    let dato;
+    try {
+        const analizado = JSON.parse(linea);
+        if (analizado === null || typeof analizado !== 'object' || Array.isArray(analizado))
+            return null;
+        dato = analizado;
+    }
+    catch {
+        return null;
+    }
+    const error = errorOf(dato.err) ?? errorOf(dato.error);
+    const mensaje = typeof dato.msg === 'string' ? dato.msg : typeof dato.message === 'string' ? dato.message : '';
+    if (!opciones.requests && REQUEST_LINES.has(mensaje))
+        return null;
+    const contexto = {};
+    for (const [clave, valor] of Object.entries(dato))
+        if (!RESERVED.has(clave))
+            contexto[clave] = valor;
+    const tiempo = dato.time;
+    return {
+        time: typeof tiempo === 'number' || typeof tiempo === 'string' ? tiempo : undefined,
+        level: (0, levels_1.normalizeLevel)(dato.level) ?? 'info',
+        message: mensaje !== '' ? mensaje : typeof error?.message === 'string' ? error.message : '',
+        channel: typeof dato.name === 'string' ? dato.name : null,
+        context: contexto,
+        error,
+    };
+}
+function errorOf(valor) {
+    if (valor === null || typeof valor !== 'object')
+        return null;
+    const candidato = valor;
+    return typeof candidato.message === 'string' || typeof candidato.stack === 'string' ? candidato : null;
+}