@gyramais/log-transport 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# @gyramais/log-transport
+
+Como o log **chega ao destino**: monta os transports (Console, File, Loki) a
+partir de configuração explícita, e registra exceção fatal com flush antes do
+exit.
+
+```ts
+import {
+  buildNestLogger,
+  redirectConsoleToNestLogger,
+  registerFatalHandlers,
+} from '@gyramais/log-transport';
+
+const { logger, lokiTransport } = buildNestLogger({
+  service: 'gyra-core',   // obrigatório
+  level: 'debug',
+  pretty: false,
+  loki: { host: 'http://loki:3100', basicAuth: '...' },
+});
+
+registerFatalHandlers(logger, lokiTransport);
+```
+
+## Serviço com mais de um logger
+
+Se o serviço monta **vários loggers no mesmo processo**, crie o transport uma vez e
+compartilhe. O worker do gyra-core monta quatro — um para a app e três para
+conexões RMQ (`src/main.worker.ts`):
+
+```ts
+import { createLokiTransport, buildNestLogger } from '@gyramais/log-transport';
+
+// UM transport para o processo inteiro
+const lokiTransport = createLokiTransport({
+  service: 'gyra-core',
+  host: process.env.LOKI_URL,
+  basicAuth: process.env.LOKI_BASIC_AUTH,
+});
+
+const { logger } = buildNestLogger({ service: 'gyra-core', lokiTransport });
+
+// e o mesmo transport nos outros loggers
+const rmqLogger = buildNestLogger({ service: 'gyra-core', lokiTransport }).logger;
+```
+
+Não é conveniência, é correção: com um transport por logger há **um batcher por
+logger**, e o `registerFatalHandlers` drena apenas o que recebeu — as linhas
+bufferizadas nos outros morrem com o processo, que é o sintoma que a entrega
+confiável existe para impedir.
+
+Passar `loki` e `lokiTransport` juntos lança erro: um pede transport novo, o outro
+pede reuso, e escolher em silêncio deixaria o consumidor com dois batchers sem
+saber.
+
+**`registerFatalHandlers` é chamado UMA vez por processo**, com o transport
+compartilhado — não um por logger. Handler de `uncaughtException` é recurso único
+do processo: registros duplicados produziriam linhas `[FATAL]` repetidas e flushes
+concorrentes no mesmo transport. O pacote ignora a chamada extra e emite
+`[FATAL-HANDLERS-DUP]` no stdout, mas o certo é chamar uma vez. Ele devolve uma
+função de `unregister`, útil em teste.
+
+## O pacote não lê `process.env`
+
+Toda configuração entra por parâmetro. Três razões, em ordem de peso:
+
+1. **Correção.** Os serviços não leem os mesmos envs: `gyra-export` lê `APP_NAME`,
+   e `gyra-file` e `gyra-websocket-server` não leem `ENVIRONMENT` nem `LOG_LEVEL`.
+   Um helper de env compartilhado mudaria o comportamento desses em silêncio.
+2. **Testabilidade.** Ler env obriga o teste a mutar estado global do processo, e
+   a suíte passa a depender da ordem de execução.
+3. **Contrato visível.** A assinatura diz o que o pacote precisa.
+
+Quem lê env é o serviço, no entrypoint. Há um teste que compila o pacote com
+`removeComments` e falha se `process.env` aparecer no código emitido.
+
+## Detalhes que não são arbitrários
+
+- **`service` é obrigatório no tipo.** O `gyra-nest-boilerplate` rotula hoje
+  `service: 'gyra-credit-policy'` por cópia de arquivo, e todo serviço novo nasce
+  logando sob o rótulo errado. Agora isso é erro de compilação.
+- **A presença de `loki` é o gate de envio**, no lugar de um booleano em string.
+- **`app` tem default `saas`**: as consultas e dashboards em produção usam
+  `{app="saas", service="gyra-x"}`.
+- **`registerFatalHandlers` é opt-in.** Instalar handler de `uncaughtException` é
+  efeito colateral no ciclo de vida do processo — importar um pacote não deve
+  mudar como o processo morre.
+- **`winston-loki: ^6.1.6`** é dependência daqui. São dois bugs corrigidos lá:
+  metadado estruturado não-string fazia o Loki responder 400 e descartar o lote
+  inteiro, e a resposta de erro era tratada como sucesso, tornando a perda 100%
+  silenciosa. O consumidor recebe a correção transitivamente.

package/dist/console-redirect.d.ts

@@ -0,0 +1,5 @@
+export interface ConsoleRedirectOptions {
+    pretty?: boolean;
+}
+export declare const redirectConsoleToNestLogger: (options?: ConsoleRedirectOptions) => void;
+//# sourceMappingURL=console-redirect.d.ts.map

package/dist/console-redirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-redirect.d.ts","sourceRoot":"","sources":["../src/console-redirect.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,sBAAsB;IAOrC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,2BAA2B,GACtC,UAAS,sBAA2B,KACnC,IAwBF,CAAC"}

package/dist/console-redirect.js

@@ -0,0 +1,37 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redirectConsoleToNestLogger = void 0;
+/*
+  Redireciona `console.*` para o Logger do Nest, para que biblioteca de terceiro (e
+  código legado) que escreve em `console` também chegue aos transports.
+
+  Saiu do `buildNestLogger` de propósito: trocar os métodos de `console` é efeito
+  colateral global do processo, e importar um pacote não deve mudar o que
+  `console.log` faz no serviço inteiro. Quem quer, chama.
+*/
+const common_1 = require("@nestjs/common");
+const redirectConsoleToNestLogger = (options = {}) => {
+    console.log = (message, ...optionalParams) => {
+        if (options.pretty) {
+            common_1.Logger.log(message, ...optionalParams);
+        }
+        else {
+            common_1.Logger.debug(message, ...optionalParams);
+        }
+    };
+    console.error = (message, data, ...optionalParams) => {
+        common_1.Logger.error(message, { data }, ...optionalParams);
+    };
+    console.warn = (message, ...optionalParams) => {
+        common_1.Logger.warn(message, ...optionalParams);
+    };
+    console.debug = (message, ...optionalParams) => {
+        common_1.Logger.debug(message, ...optionalParams);
+    };
+    console.info = (message, ...optionalParams) => {
+        common_1.Logger.verbose(message, ...optionalParams);
+    };
+};
+exports.redirectConsoleToNestLogger = redirectConsoleToNestLogger;
+//# sourceMappingURL=console-redirect.js.map

package/dist/console-redirect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-redirect.js","sourceRoot":"","sources":["../src/console-redirect.ts"],"names":[],"mappings":";AAAA,uDAAuD;;;AAEvD;;;;;;;EAOE;AAEF,2CAAwC;AAYjC,MAAM,2BAA2B,GAAG,CACzC,UAAkC,EAAE,EAC9B,EAAE;IACR,OAAO,CAAC,GAAG,GAAG,CAAC,OAAa,EAAE,GAAG,cAAqB,EAAE,EAAE;QACxD,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,eAAM,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;QACzC,CAAC;aAAM,CAAC;YACN,eAAM,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,CAAC,KAAK,GAAG,CAAC,OAAa,EAAE,IAAU,EAAE,GAAG,cAAqB,EAAE,EAAE;QACtE,eAAM,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,EAAE,GAAG,cAAc,CAAC,CAAC;IACrD,CAAC,CAAC;IAEF,OAAO,CAAC,IAAI,GAAG,CAAC,OAAa,EAAE,GAAG,cAAqB,EAAE,EAAE;QACzD,eAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;IAC1C,CAAC,CAAC;IAEF,OAAO,CAAC,KAAK,GAAG,CAAC,OAAa,EAAE,GAAG,cAAqB,EAAE,EAAE;QAC1D,eAAM,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;IAC3C,CAAC,CAAC;IAEF,OAAO,CAAC,IAAI,GAAG,CAAC,OAAa,EAAE,GAAG,cAAqB,EAAE,EAAE;QACzD,eAAM,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;IAC7C,CAAC,CAAC;AACJ,CAAC,CAAC;AA1BW,QAAA,2BAA2B,+BA0BtC"}

package/dist/fatal-handlers.d.ts

@@ -0,0 +1,21 @@
+import { LoggerService } from '@nestjs/common';
+import LokiTransport = require('winston-loki');
+interface FatalHandlersOptions {
+    flushTimeoutMs?: number;
+    exit?: (code: number) => void;
+}
+/**
+ * Entrega ao Loki o que está bufferizado e só então devolve o controle,
+ * desistindo depois de `timeoutMs`. Nunca lança: no caminho de saída do
+ * processo, uma falha de flush não pode virar um segundo erro.
+ *
+ * O `flush()` do winston-loki apenas *aguarda* o laço periódico de envio, que
+ * pode estar a um intervalo inteiro de distância; quem está encerrando precisa
+ * *forçar* o envio agora. `close()` faz exatamente isso — interrompe a espera do
+ * laço e manda o batch pendente — e o `flush()` seguinte resolve quando esse
+ * envio termina.
+ */
+declare const flushLokiTransport: (transport: LokiTransport | undefined, timeoutMs?: number) => Promise<void>;
+declare const registerFatalHandlers: (logger: LoggerService, transport: LokiTransport | undefined, options?: FatalHandlersOptions) => (() => void);
+export { registerFatalHandlers, flushLokiTransport };
+//# sourceMappingURL=fatal-handlers.d.ts.map

package/dist/fatal-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fatal-handlers.d.ts","sourceRoot":"","sources":["../src/fatal-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,aAAa,GAAG,QAAQ,cAAc,CAAC,CAAC;AAU/C,UAAU,oBAAoB;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/B;AAwBD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,kBAAkB,GACtB,WAAW,aAAa,GAAG,SAAS,EACpC,kBAA4B,KAC3B,OAAO,CAAC,IAAI,CA6Bd,CAAC;AAmDF,QAAA,MAAM,qBAAqB,GACzB,QAAQ,aAAa,EACrB,WAAW,aAAa,GAAG,SAAS,EACpC,UAAS,oBAAyB,KACjC,CAAC,MAAM,IAAI,CA6Fb,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/fatal-handlers.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushLokiTransport = exports.registerFatalHandlers = void 0;
+/*
+  O flush no caminho do crash é limitado no tempo de propósito: um Loki
+  indisponível não pode impedir o pod de morrer e reiniciar.
+*/
+const FLUSH_TIMEOUT_MS = 2000;
+/*
+  Winston entrega a linha ao transport por stream, num tick posterior ao
+  `logger.error()`. Sem esperar por essa entrega, o batch ainda está vazio quando
+  o flush é pedido — e aí o flush resolve na hora e o processo sai levando a linha
+  embora. O transport emite `logged` quando recebe.
+*/
+const LOGGED_HANDOFF_TIMEOUT_MS = 100;
+const waitForHandoff = (transport, timeoutMs) => new Promise((resolve) => {
+    const done = () => {
+        clearTimeout(timer);
+        transport.off?.('logged', done);
+        resolve();
+    };
+    const timer = setTimeout(done, timeoutMs);
+    transport.once?.('logged', done);
+});
+/**
+ * Entrega ao Loki o que está bufferizado e só então devolve o controle,
+ * desistindo depois de `timeoutMs`. Nunca lança: no caminho de saída do
+ * processo, uma falha de flush não pode virar um segundo erro.
+ *
+ * O `flush()` do winston-loki apenas *aguarda* o laço periódico de envio, que
+ * pode estar a um intervalo inteiro de distância; quem está encerrando precisa
+ * *forçar* o envio agora. `close()` faz exatamente isso — interrompe a espera do
+ * laço e manda o batch pendente — e o `flush()` seguinte resolve quando esse
+ * envio termina.
+ */
+const flushLokiTransport = async (transport, timeoutMs = FLUSH_TIMEOUT_MS) => {
+    if (!transport?.flush)
+        return;
+    let timer;
+    const drain = async () => {
+        await waitForHandoff(transport, Math.min(LOGGED_HANDOFF_TIMEOUT_MS, timeoutMs));
+        transport.close?.();
+        await transport.flush();
+    };
+    try {
+        await Promise.race([
+            drain(),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, timeoutMs);
+            }),
+        ]);
+    }
+    catch {
+        /*
+          Silencioso por escolha: quem chama já está encerrando o processo e a linha
+          de erro do flush não teria para onde ir.
+        */
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+};
+exports.flushLokiTransport = flushLokiTransport;
+const describeReason = (reason) => {
+    if (reason instanceof Error) {
+        return {
+            message: `${reason.name}: ${reason.message}`,
+            stack: reason.stack ?? '',
+        };
+    }
+    return { message: String(reason), stack: '' };
+};
+/**
+ * Registra os handlers de exceção fatal do processo.
+ *
+ * Sem eles, o handler padrão do Node imprime a stack direto no stderr — sem
+ * passar por nenhum transport do winston — e o crash fica invisível na
+ * observabilidade, encontrável apenas por `kubectl logs --previous`.
+ *
+ * O processo continua morrendo: depois de uma exceção não capturada o estado é
+ * indefinido, e reiniciar é o comportamento correto. O que muda é o crash passar
+ * a ficar registrado.
+ */
+/*
+  Handler de exceção fatal é recurso ÚNICO do processo, e o guard de reentrância
+  vive no closure de cada chamada — então dois registros são dois guards, e um
+  único erro fatal dispara os dois. Medido: quatro registros produziram quatro
+  linhas `[FATAL]`, quatro flushes concorrentes no mesmo transport e quatro
+  chamadas de exit.
+
+  O risco cresceu quando o pacote passou a suportar vários loggers com um
+  transport compartilhado (ver `createLokiTransport`): fica natural registrar um
+  handler por logger.
+
+  Este é o único estado global do pacote, e a distinção importa: ele descreve o
+  PROCESSO — se os handlers já estão instalados nele —, não configuração. Config
+  em variável global é o que `options.ts` recusa; isto é outra coisa.
+
+  `Symbol.for` e não um `let` de módulo: sobrevive a duas instâncias do pacote na
+  árvore de dependências, que é exatamente o caso em que o registro duplicado
+  aconteceria sem ninguém perceber.
+*/
+const REGISTERED = Symbol.for('@gyramais/log-transport.fatalHandlersRegistered');
+const registerFatalHandlers = (logger, transport, options = {}) => {
+    const target = globalThis;
+    if (target[REGISTERED]) {
+        /*
+          Avisa em vez de ignorar em silêncio: registro duplicado é erro de
+          integração do consumidor, e descobrir isso durante um crash em produção é
+          o pior momento possível.
+        */
+        process.stdout.write(`${JSON.stringify({
+            level: 'warn',
+            message: '[FATAL-HANDLERS-DUP] registerFatalHandlers chamado mais de uma vez ' +
+                'neste processo; a chamada extra foi ignorada. Chame uma vez, com o ' +
+                'transport compartilhado.',
+            timestamp: new Date().toISOString(),
+        })}\n`);
+        return () => undefined;
+    }
+    target[REGISTERED] = true;
+    const flushTimeoutMs = options.flushTimeoutMs ?? FLUSH_TIMEOUT_MS;
+    const exit = options.exit ?? ((code) => process.exit(code));
+    /*
+      Um segundo erro fatal enquanto o primeiro ainda está sendo flushado não pode
+      reiniciar o ciclo — senão o processo nunca chega ao exit.
+    */
+    let handling = false;
+    const handleFatal = async (origin, reason) => {
+        if (handling)
+            return;
+        handling = true;
+        /*
+          O exit vai no finally porque o guard de reentrância já está levantado: se
+          registrar ou flushar falhasse aqui, uma segunda passagem sairia na primeira
+          linha e o processo ficaria pendurado — travado num estado indefinido em vez
+          de reiniciar.
+        */
+        try {
+            const { message, stack } = describeReason(reason);
+            logger.error(`[FATAL] ${origin}: ${message}`, {
+                origin,
+                /*
+                  String, não array: o Loki exige valores string na structured metadata e
+                  rejeita a requisição inteira quando recebe outra coisa.
+                */
+                stack,
+            });
+            await flushLokiTransport(transport, flushTimeoutMs);
+        }
+        finally {
+            exit(1);
+        }
+    };
+    /*
+      O catch fecha o laço: sem ele, uma falha dentro do handler de
+      unhandledRejection viraria uma nova unhandledRejection.
+    */
+    const onFatal = (origin) => (reason) => {
+        handleFatal(origin, reason).catch(() => {
+            /*
+              Vazio de propósito: o processo já está encerrando, e uma linha de erro
+              daqui não teria para onde ir.
+            */
+        });
+    };
+    const onUncaught = onFatal('uncaughtException');
+    const onRejection = onFatal('unhandledRejection');
+    process.on('uncaughtException', onUncaught);
+    process.on('unhandledRejection', onRejection);
+    /*
+      Desfaz o registro e libera o guard. Em produção o processo não desregistra —
+      ele morre. Isto existe para o teste poder registrar de novo na próxima
+      execução, e é o que torna o guard acima verificável em vez de um efeito
+      global impossível de exercitar.
+    */
+    return () => {
+        process.off('uncaughtException', onUncaught);
+        process.off('unhandledRejection', onRejection);
+        delete target[REGISTERED];
+    };
+};
+exports.registerFatalHandlers = registerFatalHandlers;
+//# sourceMappingURL=fatal-handlers.js.map

package/dist/fatal-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fatal-handlers.js","sourceRoot":"","sources":["../src/fatal-handlers.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { buildNestLogger, createLokiTransport } from './logger';
+export type { BuiltLogger, CreateLokiTransportOptions } from './logger';
+export { redirectConsoleToNestLogger } from './console-redirect';
+export type { ConsoleRedirectOptions } from './console-redirect';
+export { registerFatalHandlers, flushLokiTransport } from './fatal-handlers';
+export { DEFAULT_APP_LABEL, DEFAULT_LEVEL, DEFAULT_LOKI_INTERVAL_SECONDS, DEFAULT_LOKI_TIMEOUT_MS, } from './options';
+export type { LoggerOptions, LokiOptions, FileOptions, LokiTransportLike, } from './options';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAChE,YAAY,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAExE,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACjE,YAAY,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE7E,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,aAAa,EACb,WAAW,EACX,WAAW,EACX,iBAAiB,GAClB,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/*
+  Entrega de log dos serviços gyra-*: monta os transports (Console, File, Loki) a
+  partir de configuração explícita, e registra exceção fatal com flush antes do
+  exit.
+
+  Nada aqui lê variável de ambiente — ver `options.ts` para o porquê. Quem lê é o
+  serviço, no entrypoint dele.
+
+  O exemplo de uso completo está no README do pacote. Ele NÃO fica aqui de
+  propósito: o exemplo mostra o consumidor lendo `process.env`, e como o build
+  publica os comentários (`removeComments: false`), essas linhas apareceriam no
+  `dist/` e fariam um grep de auditoria acusar o pacote de ler ambiente.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOKI_TIMEOUT_MS = exports.DEFAULT_LOKI_INTERVAL_SECONDS = exports.DEFAULT_LEVEL = exports.DEFAULT_APP_LABEL = exports.flushLokiTransport = exports.registerFatalHandlers = exports.redirectConsoleToNestLogger = exports.createLokiTransport = exports.buildNestLogger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "buildNestLogger", { enumerable: true, get: function () { return logger_1.buildNestLogger; } });
+Object.defineProperty(exports, "createLokiTransport", { enumerable: true, get: function () { return logger_1.createLokiTransport; } });
+var console_redirect_1 = require("./console-redirect");
+Object.defineProperty(exports, "redirectConsoleToNestLogger", { enumerable: true, get: function () { return console_redirect_1.redirectConsoleToNestLogger; } });
+var fatal_handlers_1 = require("./fatal-handlers");
+Object.defineProperty(exports, "registerFatalHandlers", { enumerable: true, get: function () { return fatal_handlers_1.registerFatalHandlers; } });
+Object.defineProperty(exports, "flushLokiTransport", { enumerable: true, get: function () { return fatal_handlers_1.flushLokiTransport; } });
+var options_1 = require("./options");
+Object.defineProperty(exports, "DEFAULT_APP_LABEL", { enumerable: true, get: function () { return options_1.DEFAULT_APP_LABEL; } });
+Object.defineProperty(exports, "DEFAULT_LEVEL", { enumerable: true, get: function () { return options_1.DEFAULT_LEVEL; } });
+Object.defineProperty(exports, "DEFAULT_LOKI_INTERVAL_SECONDS", { enumerable: true, get: function () { return options_1.DEFAULT_LOKI_INTERVAL_SECONDS; } });
+Object.defineProperty(exports, "DEFAULT_LOKI_TIMEOUT_MS", { enumerable: true, get: function () { return options_1.DEFAULT_LOKI_TIMEOUT_MS; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;EAYE;;;AAEF,mCAAgE;AAAvD,yGAAA,eAAe,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAG7C,uDAAiE;AAAxD,+HAAA,2BAA2B,OAAA;AAGpC,mDAA6E;AAApE,uHAAA,qBAAqB,OAAA;AAAE,oHAAA,kBAAkB,OAAA;AAElD,qCAKmB;AAJjB,4GAAA,iBAAiB,OAAA;AACjB,wGAAA,aAAa,OAAA;AACb,wHAAA,6BAA6B,OAAA;AAC7B,kHAAA,uBAAuB,OAAA"}

package/dist/logger.d.ts

@@ -0,0 +1,36 @@
+import LokiTransport = require('winston-loki');
+import type { LoggerService } from '@nestjs/common';
+import { LoggerOptions, LokiOptions } from './options';
+export interface BuiltLogger {
+    logger: LoggerService;
+    lokiTransport?: LokiTransport;
+}
+export interface CreateLokiTransportOptions extends LokiOptions {
+    service: string;
+    app?: string;
+    instance?: string;
+    pretty?: boolean;
+}
+/**
+ * Constrói o transport do Loki isoladamente, para o consumidor COMPARTILHAR um
+ * único batcher entre vários loggers do mesmo processo.
+ *
+ * Use isto quando o serviço monta mais de um logger — o worker do gyra-core monta
+ * quatro. Com um transport por logger, cada um tem seu batcher, e o flush de
+ * exceção fatal cobre só um deles.
+ *
+ *     const lokiTransport = createLokiTransport({ service: 'gyra-core', host });
+ *     const { logger } = buildNestLogger({ service: 'gyra-core', lokiTransport });
+ *     // ...e o mesmo `lokiTransport` nos outros loggers do processo
+ */
+export declare const createLokiTransport: (options: CreateLokiTransportOptions) => LokiTransport;
+/**
+ * Monta o logger do Nest com os transports pedidos e devolve, junto, o transport
+ * do Loki — necessário para `registerFatalHandlers` dar flush antes do exit.
+ *
+ * Não instala nada no processo: nem handler de exceção, nem redirecionamento de
+ * `console.*`. Esses são opt-in explícito, porque mexem no ciclo de vida do
+ * processo.
+ */
+export declare const buildNestLogger: (options: LoggerOptions) => BuiltLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AA4BA,OAAO,aAAa,GAAG,QAAQ,cAAc,CAAC,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD,OAAO,EAKL,aAAa,EACb,WAAW,EACZ,MAAM,WAAW,CAAC;AAQnB,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,aAAa,CAAC;IAOtB,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAoED,MAAM,WAAW,0BAA2B,SAAQ,WAAW;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,0BAA0B,KAClC,aAeF,CAAC;AAkCF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,aAAa,KAAG,WAoDxD,CAAC"}

package/dist/logger.js

@@ -0,0 +1,176 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNestLogger = exports.createLokiTransport = void 0;
+/*
+  PROVENIÊNCIA: derivado de gyra-core/src/common/logger/LoggerFactory.ts na branch
+  GYR-1555 (tag `backup/GYR-1555-pre-close`), onde o defeito de entrega ao Loki foi
+  diagnosticado e provado contra um Loki 3.0 real: antes, 21 linhas enviadas e 0
+  chegando, sem nenhum erro reportado; depois, 21 de 21.
+
+  Diferenças em relação à fonte, todas deliberadas:
+
+  - Nenhuma leitura de `process.env` — ver `options.ts`.
+  - Sem singleton de módulo. A fonte guardava o transport numa variável de módulo
+    para o handler de exceção fatal alcançá-lo; aqui ele volta no retorno, porque
+    estado global no pacote é o mesmo problema de ler env com outra roupa.
+
+    O singleton da fonte, porém, resolvia um problema real que o retorno sozinho
+    não resolve: serviço que monta VÁRIOS loggers no mesmo processo — o worker do
+    gyra-core monta quatro — teria um batcher por logger, e o flush de exceção
+    fatal drenaria só um deles. Para isso existe `createLokiTransport`: o
+    consumidor cria o transport uma vez e passa o mesmo em `lokiTransport`. O
+    compartilhamento fica explícito no call site, em vez de escondido no módulo.
+  - O redirecionamento de `console.*` saiu para `console-redirect.ts`, como opt-in
+    explícito: é efeito colateral de processo, e importar um pacote não deve mudar
+    o que `console.log` faz.
+*/
+const winston_1 = require("winston");
+const nest_winston_1 = require("nest-winston");
+const LokiTransport = require("winston-loki");
+const os_1 = require("os");
+const options_1 = require("./options");
+const formatMeta = (meta) => {
+    const splat = meta[Symbol.for('splat')];
+    if (splat?.[0].stack) {
+        return ' ' + JSON.stringify(splat?.[0].stack?.[0], null, 2);
+    }
+    if (splat && splat.length) {
+        const obj = splat?.[0]?.context ?? splat;
+        if (typeof obj === 'string') {
+            return ' ' + obj;
+        }
+        if (Array.isArray(obj) &&
+            obj.length === 1 &&
+            typeof obj[0] === 'object' &&
+            Object.keys(obj[0]).length === 1 &&
+            obj[0].context === undefined) {
+            return '';
+        }
+        return ' ' + JSON.stringify(obj, null, 2);
+    }
+    return '';
+};
+const buildPrettyFormat = () => {
+    const localFormat = winston_1.format.printf(({ message, level, ..._meta }) => {
+        const color = {
+            white: '\x1B[38;2;173;190;203m',
+            blue: '\x1B[34m',
+            red: '\x1B[31m',
+            yellow: '\x1B[33m',
+            cyan: '\x1B[36m',
+            magenta: '\x1B[35m',
+            reset: '\x1B[0m',
+        };
+        const levelColor = {
+            info: color.white,
+            error: color.red,
+            warn: color.yellow,
+            debug: color.cyan,
+            verbose: color.magenta,
+        };
+        const currentColor = levelColor[level];
+        const meta = formatMeta(_meta);
+        /*
+          `verbose` é o maior level, com 7 letras; +1 para sempre sobrar espaço.
+        */
+        let finalMessage = `${level.padEnd(8)}  ${message}${meta ?? ''}`;
+        finalMessage = finalMessage.replaceAll('\n', `\n${currentColor ?? 'red'}`);
+        return `${currentColor}` + finalMessage + `${color.reset}`;
+    });
+    return winston_1.format.combine(winston_1.format.splat(), localFormat);
+};
+/**
+ * Constrói o transport do Loki isoladamente, para o consumidor COMPARTILHAR um
+ * único batcher entre vários loggers do mesmo processo.
+ *
+ * Use isto quando o serviço monta mais de um logger — o worker do gyra-core monta
+ * quatro. Com um transport por logger, cada um tem seu batcher, e o flush de
+ * exceção fatal cobre só um deles.
+ *
+ *     const lokiTransport = createLokiTransport({ service: 'gyra-core', host });
+ *     const { logger } = buildNestLogger({ service: 'gyra-core', lokiTransport });
+ *     // ...e o mesmo `lokiTransport` nos outros loggers do processo
+ */
+const createLokiTransport = (options) => {
+    const { service, app, instance, pretty, ...loki } = options;
+    return buildLokiTransport(loki, {
+        service,
+        app: app ?? options_1.DEFAULT_APP_LABEL,
+        instance: instance ?? (0, os_1.hostname)(),
+        ...loki.labels,
+    }, pretty
+        ? buildPrettyFormat()
+        : winston_1.format.combine(winston_1.format.timestamp(), winston_1.format.json()));
+};
+exports.createLokiTransport = createLokiTransport;
+const buildLokiTransport = (loki, labels, lineFormat) => new LokiTransport({
+    host: loki.host,
+    basicAuth: loki.basicAuth,
+    json: true,
+    labels,
+    interval: loki.interval ?? options_1.DEFAULT_LOKI_INTERVAL_SECONDS,
+    batching: true,
+    timeout: loki.timeout ?? options_1.DEFAULT_LOKI_TIMEOUT_MS,
+    format: lineFormat,
+    /*
+      A falha de entrega tem que ser audível: enquanto era silenciosa, o serviço
+      perdeu ~99,5% dos seus logs sem ninguém notar. Escreve direto no console
+      porque passar pelo logger completo realimentaria o Loki num laço de erro.
+    */
+    onConnectionError: (err) => process.stdout.write(`${JSON.stringify({
+        level: 'error',
+        message: `[LOKI-SHIP-FAIL] status=${err?.statusCode ?? 'none'} ${err?.message ?? err}`,
+        timestamp: new Date().toISOString(),
+    })}\n`),
+});
+/**
+ * Monta o logger do Nest com os transports pedidos e devolve, junto, o transport
+ * do Loki — necessário para `registerFatalHandlers` dar flush antes do exit.
+ *
+ * Não instala nada no processo: nem handler de exceção, nem redirecionamento de
+ * `console.*`. Esses são opt-in explícito, porque mexem no ciclo de vida do
+ * processo.
+ */
+const buildNestLogger = (options) => {
+    const lineFormat = options.pretty
+        ? buildPrettyFormat()
+        : winston_1.format.combine(winston_1.format.timestamp(), winston_1.format.json());
+    /*
+      Passar os dois é ambíguo: um pede para construir um transport novo, o outro
+      para reusar um existente. Falhar alto é melhor que escolher em silêncio e
+      deixar o consumidor com dois batchers sem saber.
+    */
+    if (options.loki && options.lokiTransport) {
+        throw new Error('[log-transport] `loki` e `lokiTransport` sao mutuamente exclusivos: ' +
+            'use `loki` para construir um transport novo, ou `lokiTransport` para ' +
+            'reusar um ja construido por createLokiTransport().');
+    }
+    const transportsList = [
+        new winston_1.transports.Console({ format: lineFormat }),
+    ];
+    let lokiTransport;
+    if (options.lokiTransport) {
+        lokiTransport = options.lokiTransport;
+        transportsList.push(lokiTransport);
+    }
+    else if (options.loki) {
+        lokiTransport = buildLokiTransport(options.loki, {
+            service: options.service,
+            app: options.app ?? options_1.DEFAULT_APP_LABEL,
+            instance: options.instance ?? (0, os_1.hostname)(),
+            ...options.loki.labels,
+        }, lineFormat);
+        transportsList.push(lokiTransport);
+    }
+    else if (options.file) {
+        transportsList.push(new winston_1.transports.File({ filename: options.file.filename }));
+    }
+    const logger = nest_winston_1.WinstonModule.createLogger({
+        level: options.level ?? options_1.DEFAULT_LEVEL,
+        transports: transportsList,
+    });
+    return { logger, lokiTransport };
+};
+exports.buildNestLogger = buildNestLogger;
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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"}