@monzori/browser 0.1.1 → 0.1.3

package/README.md

@@ -4,7 +4,22 @@ Captura erros globais, promises rejeitadas, reporte manual e console error/warn.
 
 Instale com npm install @monzori/browser. Versão inicial para piloto privado.
 
-O endpoint hospedado depende da implantação do serviço. Configure um endpoint explícito para testes locais.
+A partir da versão 0.1.2, falhas recuperáveis de importação, inicialização e envio afetam somente a coleta. Recursos de navegador indisponíveis devolvem um cliente inativo; inicialização parcial desfaz os hooks instalados. A fila é limitada e o envio tem prazo de três segundos, backoff e tratamento terminal de rejeições.
+
+Para isolar também falhas de download/avaliação do módulo, carregue o SDK após iniciar o React, sem aguardá-lo no caminho de renderização:
+
+```js
+// Execute após iniciar o frontend; falhas encerram somente a coleta.
+void import('@monzori/browser')
+  .then(({default: Monzori}) => {
+    Monzori.start({apiKey: 'IDENTIFICADOR_PUBLICO', release: 'web-2026.11.14'});
+  })
+  .catch(() => {});
+```
+
+Não condicione login, navegação ou ações do usuário ao resultado de flush(). Um beforeSend fornecido pela aplicação deve ser curto: código executado no mesmo contexto JavaScript não pode ser isolado de callbacks que nunca retornam ou do esgotamento de recursos do navegador.
+
+O piloto hospedado usa o endereço padrão abaixo. Para obter a chave, abra **Integração** na sua aplicação frontend no painel. Configure um endpoint explícito somente para testes locais.
 
 ```ts
 import Monzori from '@monzori/browser';
@@ -20,6 +35,18 @@ monzori.captureException(new Error('Evento explícito de teste'));
 
 O endereço padrão é `https://ingest.monzori.com.br/v1/web/events`. `apiKey` é o identificador público restrito à ingestão da fonte, não uma senha de administração. A inicialização devolve o client usado no Error Boundary e no reporte manual. Há também o export nomeado `start`.
 
+Na versão 0.1.3, erros tratados podem ser enviados por `Monzori.notify(error, contextoOpcional)` ou pelo export nomeado `notify`. Aceita Error, string e os valores já suportados por captureException, usando o mesmo client ativo, sanitização, fila e transporte protegido. Não exige endpoint separado. Antes de start ou depois de close, notify não envia e não lança. O método client.captureException continua compatível.
+
+```js
+try {
+  // ação da aplicação
+} catch (error) {
+  Monzori.notify(error, {flow: 'login'});
+}
+```
+
+Uma resposta HTTP400 tratada não gera erro global: é preciso reportá-la explicitamente quando representar um problema que se deseja monitorar. Chamadas a Bugsnag.notify não são interceptadas pelo Monzori. No frontend cliente, a função reportError centraliza o reporte aos dois SDKs, isolando as falhas de cada destino; durante a carga inicial do chunk, espera no máximo3s e mantém no máximo20 chamadas pendentes. Nenhum reporte é aguardado pela ação da aplicação.
+
 `endpoint` é uma opção avançada: para testes locais, informar `http://localhost:3333/v1/web/events`; destinos fora de loopback exigem HTTPS. Um endpoint explícito inválido desabilita o envio, sem fallback silencioso. O endereço padrão não implica que a infraestrutura do piloto já esteja publicada.
 
 Compatibilidade: `initMonzori({publicKey, release, endpoint})` continua funcionando como alias legado, usando o mesmo client; preferir `Monzori.start({apiKey, release})` nas novas integrações. Escolher `apiKey` ou `publicKey`, sem combinar os dois. A primeira inicialização fica ativa até `close()`, sem duplicar listeners em chamadas subsequentes.
@@ -32,7 +59,7 @@ import { MonzoriErrorBoundary } from '@monzori/browser/react';
 </MonzoriErrorBoundary>
 ```
 
-Cadastre a origem HTTPS exata no painel; HTTP é aceito apenas em loopback local. O identificador público só admite eventos naquele vínculo, sem permitir leitura ou upload de mapas. A URL de ingresso deve aceitar CORS para a origem cadastrada; a instalação local usa http://localhost:3333/v1/web/events. Release precisa coincidir com o upload privado dos source maps. Identificadores de release devem ser únicos por versão; não reutilizá-los para substituir mapas de um mesmo artefato.
+Novas integrações podem receber eventos de qualquer site. A restrição opcional fica em **Integração → Configurações → Domínios permitidos**; integrações anteriores mantêm suas restrições. HTTP é aceito apenas em loopback local. O identificador público só admite eventos naquele vínculo, sem permitir leitura ou upload de mapas. A instalação local usa http://localhost:3333/v1/web/events. Release precisa coincidir com o upload privado dos source maps. Identificadores de release devem ser únicos por versão; não reutilizá-los para substituir mapas de um mesmo artefato.
 
 Buffer somente em memória, sem cookies/storage/DOM/formulários/identificação de visitantes automáticos. Limites: 100 eventos/256 KiB, flush a cada 5 segundos ou 20 eventos, até 50 eventos e 32 KiB por pedido. O SDK reserva espaço para contexto do servidor e descarta um evento serializado acima de 6 KiB; o teto canônico na API é 8 KiB. Reenvio com o mesmo ID, backoff de 1–60 segundos com jitter, até 24 horas de idade; fechar a página pode perder eventos não admitidos. No máximo 60 entradas de console por minuto/página. O SDK não registra seus próprios diagnósticos no console monitorado.
 

package/dist/index.d.ts

@@ -46,7 +46,9 @@ export type Client = {
 export declare function start(options: Options): Client;
 /** @deprecated Use Monzori.start(options) or the named start export. */
 export declare const initMonzori: typeof start;
+export declare function notify(error: unknown, context?: unknown): void;
 declare const Monzori: {
     start: typeof start;
+    notify: typeof notify;
 };
 export default Monzori;

package/dist/index.js

@@ -1,10 +1,28 @@
 import { cleanText, cleanUrl, safeValue } from './sanitize.js';
 export const DEFAULT_ENDPOINT = 'https://ingest.monzori.com.br/v1/web/events';
 let active;
-const encode = new TextEncoder();
 export function start(options) {
     if (active)
         return active;
+    const restorers = [];
+    try {
+        return createClient(options, restorers);
+    }
+    catch {
+        for (const restore of restorers.reverse()) {
+            try {
+                restore();
+            }
+            catch { /* best effort cleanup */ }
+        }
+        const client = { captureException: () => { }, captureMessage: () => { }, flush: async () => { }, close: () => { if (active === client)
+                active = undefined; }, stats: () => ({ pending: 0, bytes: 0, dropped: 0, retries: 0, confirmed: 0, disabled: true }) };
+        active = client;
+        return client;
+    }
+}
+function createClient(options, restorers) {
+    const encode = new TextEncoder();
     let endpoint = '', apiKey = '', disabled = false;
     try {
         apiKey = options.apiKey ?? options.publicKey ?? '';
@@ -26,7 +44,7 @@ export function start(options) {
     let pending;
     let controller;
     const protectedIds = new Set();
-    const restorers = [];
+    const disable = () => { disabled = true; queue = []; bytes = 0; protectedIds.clear(); };
     const expired = () => { const keep = queue.filter(entry => { if (Date.now() - Date.parse(entry.event.occurred_at) > 86400000) {
         bytes -= entry.size;
         dropped++;
@@ -92,6 +110,15 @@ export function start(options) {
         }
     }
     function flush() {
+        try {
+            return send();
+        }
+        catch {
+            disable();
+            return Promise.resolve();
+        }
+    }
+    function send() {
         if (pending)
             return pending;
         if (disabled || closed || Date.now() < nextAttempt)
@@ -111,10 +138,16 @@ export function start(options) {
         if (!batch.length)
             return Promise.resolve();
         pending = Promise.resolve().then(async () => {
-            controller = new AbortController();
-            const timeout = setTimeout(() => controller?.abort(), 3000);
+            let timeout;
             try {
-                const response = await fetch(endpoint, { method: 'POST', headers: { 'content-type': 'application/json', 'x-monzori-key': apiKey }, body: JSON.stringify({ events: batch.map(e => e.event) }), credentials: 'omit', referrerPolicy: 'no-referrer', keepalive: true, signal: controller.signal });
+                const requestController = new AbortController();
+                controller = requestController;
+                const deadline = new Promise((_, reject) => { timeout = setTimeout(() => { try {
+                    requestController.abort();
+                }
+                catch { } reject(Error('timeout')); }, 3000); });
+                const request = Promise.resolve().then(() => fetch(endpoint, { method: 'POST', headers: { 'content-type': 'application/json', 'x-monzori-key': apiKey }, body: JSON.stringify({ events: batch.map(e => e.event) }), credentials: 'omit', referrerPolicy: 'no-referrer', keepalive: true, signal: requestController.signal }));
+                const response = await Promise.race([request, deadline]);
                 if (response.status === 202 || [400, 409, 413, 415, 422].includes(response.status)) {
                     const ids = new Set(batch.map(e => e.event.event_id));
                     queue = queue.filter(e => { if (ids.has(e.event.event_id)) {
@@ -145,31 +178,53 @@ export function start(options) {
                 }
             }
             finally {
-                clearTimeout(timeout);
+                try {
+                    clearTimeout(timeout);
+                }
+                catch { }
                 protectedIds.clear();
                 pending = undefined;
                 controller = undefined;
             }
-        });
+        }).catch(() => { disable(); pending = undefined; });
         return pending;
     }
     const client = { captureException: exception, captureMessage: (message, severity = 'info', context) => capture(message, '', 'manual', severity, context), flush,
         stats: () => ({ pending: queue.length, bytes, dropped, retries, confirmed, disabled }),
-        close: () => { closed = true; controller?.abort(); restorers.forEach(fn => fn()); queue = []; bytes = 0; if (active === client)
+        close: () => { closed = true; try {
+            controller?.abort();
+        }
+        catch { } for (const restore of restorers.splice(0).reverse()) {
+            try {
+                restore();
+            }
+            catch { }
+        } queue = []; bytes = 0; if (active === client)
             active = undefined; }
     };
     if (!disabled) {
-        const onError = (event) => { if (event.error)
-            exception(event.error, {}, 'js_error');
-        else if (event.message)
-            capture(event.message, event.filename ? `${event.filename}:${event.lineno}:${event.colno}` : '', 'js_error', 'error'); };
-        const onRejection = (event) => exception(event.reason, {}, 'promise_rejection');
-        const onVisibility = () => { if (document.visibilityState === 'hidden')
-            void flush(); };
+        const onError = (event) => { try {
+            if (event.error)
+                exception(event.error, {}, 'js_error');
+            else if (event.message)
+                capture(event.message, event.filename ? `${event.filename}:${event.lineno}:${event.colno}` : '', 'js_error', 'error');
+        }
+        catch { } };
+        const onRejection = (event) => { try {
+            exception(event.reason, {}, 'promise_rejection');
+        }
+        catch { } };
+        const onVisibility = () => { try {
+            if (document.visibilityState === 'hidden')
+                void flush();
+        }
+        catch { } };
+        restorers.push(() => window.removeEventListener('error', onError));
         window.addEventListener('error', onError);
+        restorers.push(() => window.removeEventListener('unhandledrejection', onRejection));
         window.addEventListener('unhandledrejection', onRejection);
+        restorers.push(() => document.removeEventListener('visibilitychange', onVisibility));
         document.addEventListener('visibilitychange', onVisibility);
-        restorers.push(() => { window.removeEventListener('error', onError); window.removeEventListener('unhandledrejection', onRejection); document.removeEventListener('visibilitychange', onVisibility); });
         if (options.console !== false) {
             let minute = 0, count = 0;
             const levels = ['error', 'warn', ...(options.console?.log ? ['log'] : []), ...(options.console?.info ? ['info'] : []), ...(options.console?.debug ? ['debug'] : [])];
@@ -202,9 +257,9 @@ export function start(options) {
                     }
                     return result;
                 };
-                console[level] = wrapped;
                 restorers.push(() => { if (console[level] === wrapped)
                     console[level] = original; });
+                console[level] = wrapped;
             }
         }
         const timer = setInterval(() => void flush(), 5000);
@@ -215,5 +270,13 @@ export function start(options) {
 }
 /** @deprecated Use Monzori.start(options) or the named start export. */
 export const initMonzori = start;
-const Monzori = { start };
+// Manual reporting uses the same guarded capture/queue as automatic errors.
+// Before start() or after close(), reporting is intentionally a no-op.
+export function notify(error, context) {
+    try {
+        active?.captureException(error, context);
+    }
+    catch { /* Telemetry never escapes into the caller. */ }
+}
+const Monzori = { start, notify };
 export default Monzori;

package/dist/react.js

@@ -5,6 +5,9 @@ export class MonzoriErrorBoundary extends Component {
         this.state = { failed: false };
     }
     static getDerivedStateFromError() { return { failed: true }; }
-    componentDidCatch(error, info) { this.props.client.captureException(error, { componentStack: info.componentStack ?? '' }, 'react_error'); }
+    componentDidCatch(error, info) { try {
+        this.props.client.captureException(error, { componentStack: info.componentStack ?? '' }, 'react_error');
+    }
+    catch { /* Telemetry must not break React's error handling. */ } }
     render() { return this.state.failed ? this.props.fallback ?? createElement('p', null, 'Não foi possível exibir este conteúdo.') : this.props.children; }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "@monzori/browser",
- "version": "0.1.1",
+ "version": "0.1.3",
  "description": "Browser error and console collection SDK for Monzori",
  "publishConfig": {
   "access": "public",