@victor-studio/monitor 0.2.0 → 0.5.0

package/dist/adapters/gemini/gemini.d.cts

@@ -0,0 +1,173 @@
+interface HeartbeatData {
+    status: 'online' | 'offline';
+    latencyMs: number;
+}
+interface RequestData {
+    method: string;
+    route: string;
+    statusCode: number;
+    responseTimeMs: number;
+    userAgent?: string;
+    region?: string;
+}
+interface VitalData {
+    name: 'LCP' | 'INP' | 'CLS' | 'FCP' | 'TTFB';
+    value: number;
+    rating: 'good' | 'needs-improvement' | 'poor';
+    page?: string;
+    deviceType?: string;
+    browser?: string;
+}
+interface ErrorData {
+    type: 'unhandled' | 'caught' | 'promise';
+    message: string;
+    stack?: string;
+    groupingKey: string;
+    route?: string;
+    method?: string;
+    statusCode?: number;
+    environment?: string;
+    commitHash?: string;
+    extra?: Record<string, string>;
+}
+interface DeployData {
+    commitHash: string;
+    branch?: string;
+    author?: string;
+    status: 'started' | 'succeeded' | 'failed';
+    buildDurationMs?: number;
+    url?: string;
+    environment?: string;
+    provider?: string;
+}
+interface AdapterData {
+    adapter: string;
+    operation: string;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+    meta?: Record<string, string>;
+}
+type MonitorEvent = {
+    type: 'heartbeat';
+    data: HeartbeatData;
+    timestamp: string;
+} | {
+    type: 'request';
+    data: RequestData;
+    timestamp: string;
+} | {
+    type: 'vital';
+    data: VitalData;
+    timestamp: string;
+} | {
+    type: 'error';
+    data: ErrorData;
+    timestamp: string;
+} | {
+    type: 'deploy';
+    data: DeployData;
+    timestamp: string;
+} | {
+    type: 'adapter';
+    data: AdapterData;
+    timestamp: string;
+};
+/** Hook para filtrar/modificar eventos antes do envio */
+type BeforeSendHook = (event: MonitorEvent) => MonitorEvent | null;
+
+interface MonitorConfig {
+    /** ID do projeto no Nuvio */
+    projectId: string;
+    /** API key gerada no Nuvio */
+    apiKey: string;
+    /** URL do endpoint de ingest */
+    endpoint: string;
+    /** Intervalo do heartbeat em ms (default: 60000) */
+    heartbeatInterval?: number;
+    /** Intervalo do flush do buffer em ms (default: 30000) */
+    flushInterval?: number;
+    /** Timeout do fetch em ms (default: 10000) */
+    timeout?: number;
+    /** Max tentativas de retry (default: 3) */
+    maxRetries?: number;
+    /** Desabilitar em desenvolvimento (default: true) */
+    disableInDev?: boolean;
+    /** Taxa de amostragem 0.0-1.0 (default: 1.0). Heartbeats nunca são amostrados */
+    sampleRate?: number;
+    /** Hook chamado antes de enfileirar cada evento. Retorna null para dropar */
+    beforeSend?: BeforeSendHook;
+    /** Habilitar logs de debug no console (default: false) */
+    debug?: boolean;
+    /** Capturar erros globais automaticamente — window.onerror (default: false) */
+    captureErrors?: boolean;
+    /** Capturar unhandled promise rejections automaticamente (default: false) */
+    captureUnhandledRejections?: boolean;
+}
+declare class MonitorClient {
+    readonly config: MonitorConfig;
+    private readonly collector;
+    private readonly logger;
+    private heartbeatTimer;
+    private globalHandlersCleanup;
+    private active;
+    constructor(config: MonitorConfig);
+    /** Inicia o monitoring (heartbeat + collector) */
+    start(): void;
+    /** Para o monitoring */
+    stop(): void;
+    /** Força um flush imediato do buffer */
+    flush(): void;
+    /** Verifica se o monitoring está ativo */
+    get isActive(): boolean;
+    /** Registra um evento de request HTTP (usado pelo middleware) */
+    trackRequest(data: RequestData): void;
+    /** Registra um Web Vital (usado pelo MonitorScript) */
+    trackVital(data: VitalData): void;
+    /** Registra um evento de adapter (DB, cache, AI, queue, email) */
+    trackAdapter(data: AdapterData): void;
+    /** Registra um erro capturado */
+    captureError(data: ErrorData): void;
+    /** Registra um evento de deploy */
+    trackDeploy(data: DeployData): void;
+    private startHeartbeat;
+    private sendHeartbeat;
+}
+
+/**
+ * Instrumenta uma chamada ao Gemini API com timing e token tracking.
+ *
+ * @example
+ * ```ts
+ * import { monitorAI } from '@victor-studio/monitor/adapters/gemini'
+ *
+ * const result = await monitorAI(monitor, 'generate', () =>
+ *   model.generateContent(prompt),
+ *   { model: 'gemini-2.5-flash' },
+ * )
+ * ```
+ */
+declare function monitorAI<T>(monitor: MonitorClient, operation: string, fn: () => Promise<T>, meta?: Record<string, string>): Promise<T>;
+/**
+ * Instrumenta uma chamada AI e extrai token usage do resultado.
+ * Específico para o formato de resposta do Google Generative AI SDK.
+ *
+ * @example
+ * ```ts
+ * const result = await monitorAIWithTokens(monitor, 'generate', async () => {
+ *   const res = await model.generateContent(prompt)
+ *   return {
+ *     result: res,
+ *     inputTokens: res.response.usageMetadata?.promptTokenCount,
+ *     outputTokens: res.response.usageMetadata?.candidatesTokenCount,
+ *   }
+ * }, { model: 'gemini-2.5-flash' })
+ * ```
+ */
+declare function monitorAIWithTokens<T>(monitor: MonitorClient, operation: string, fn: () => Promise<{
+    result: T;
+    inputTokens?: number;
+    outputTokens?: number;
+}>, meta?: Record<string, string>): Promise<T>;
+
+export { monitorAI, monitorAIWithTokens };

package/dist/adapters/gemini/gemini.d.ts

@@ -0,0 +1,173 @@
+interface HeartbeatData {
+    status: 'online' | 'offline';
+    latencyMs: number;
+}
+interface RequestData {
+    method: string;
+    route: string;
+    statusCode: number;
+    responseTimeMs: number;
+    userAgent?: string;
+    region?: string;
+}
+interface VitalData {
+    name: 'LCP' | 'INP' | 'CLS' | 'FCP' | 'TTFB';
+    value: number;
+    rating: 'good' | 'needs-improvement' | 'poor';
+    page?: string;
+    deviceType?: string;
+    browser?: string;
+}
+interface ErrorData {
+    type: 'unhandled' | 'caught' | 'promise';
+    message: string;
+    stack?: string;
+    groupingKey: string;
+    route?: string;
+    method?: string;
+    statusCode?: number;
+    environment?: string;
+    commitHash?: string;
+    extra?: Record<string, string>;
+}
+interface DeployData {
+    commitHash: string;
+    branch?: string;
+    author?: string;
+    status: 'started' | 'succeeded' | 'failed';
+    buildDurationMs?: number;
+    url?: string;
+    environment?: string;
+    provider?: string;
+}
+interface AdapterData {
+    adapter: string;
+    operation: string;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+    meta?: Record<string, string>;
+}
+type MonitorEvent = {
+    type: 'heartbeat';
+    data: HeartbeatData;
+    timestamp: string;
+} | {
+    type: 'request';
+    data: RequestData;
+    timestamp: string;
+} | {
+    type: 'vital';
+    data: VitalData;
+    timestamp: string;
+} | {
+    type: 'error';
+    data: ErrorData;
+    timestamp: string;
+} | {
+    type: 'deploy';
+    data: DeployData;
+    timestamp: string;
+} | {
+    type: 'adapter';
+    data: AdapterData;
+    timestamp: string;
+};
+/** Hook para filtrar/modificar eventos antes do envio */
+type BeforeSendHook = (event: MonitorEvent) => MonitorEvent | null;
+
+interface MonitorConfig {
+    /** ID do projeto no Nuvio */
+    projectId: string;
+    /** API key gerada no Nuvio */
+    apiKey: string;
+    /** URL do endpoint de ingest */
+    endpoint: string;
+    /** Intervalo do heartbeat em ms (default: 60000) */
+    heartbeatInterval?: number;
+    /** Intervalo do flush do buffer em ms (default: 30000) */
+    flushInterval?: number;
+    /** Timeout do fetch em ms (default: 10000) */
+    timeout?: number;
+    /** Max tentativas de retry (default: 3) */
+    maxRetries?: number;
+    /** Desabilitar em desenvolvimento (default: true) */
+    disableInDev?: boolean;
+    /** Taxa de amostragem 0.0-1.0 (default: 1.0). Heartbeats nunca são amostrados */
+    sampleRate?: number;
+    /** Hook chamado antes de enfileirar cada evento. Retorna null para dropar */
+    beforeSend?: BeforeSendHook;
+    /** Habilitar logs de debug no console (default: false) */
+    debug?: boolean;
+    /** Capturar erros globais automaticamente — window.onerror (default: false) */
+    captureErrors?: boolean;
+    /** Capturar unhandled promise rejections automaticamente (default: false) */
+    captureUnhandledRejections?: boolean;
+}
+declare class MonitorClient {
+    readonly config: MonitorConfig;
+    private readonly collector;
+    private readonly logger;
+    private heartbeatTimer;
+    private globalHandlersCleanup;
+    private active;
+    constructor(config: MonitorConfig);
+    /** Inicia o monitoring (heartbeat + collector) */
+    start(): void;
+    /** Para o monitoring */
+    stop(): void;
+    /** Força um flush imediato do buffer */
+    flush(): void;
+    /** Verifica se o monitoring está ativo */
+    get isActive(): boolean;
+    /** Registra um evento de request HTTP (usado pelo middleware) */
+    trackRequest(data: RequestData): void;
+    /** Registra um Web Vital (usado pelo MonitorScript) */
+    trackVital(data: VitalData): void;
+    /** Registra um evento de adapter (DB, cache, AI, queue, email) */
+    trackAdapter(data: AdapterData): void;
+    /** Registra um erro capturado */
+    captureError(data: ErrorData): void;
+    /** Registra um evento de deploy */
+    trackDeploy(data: DeployData): void;
+    private startHeartbeat;
+    private sendHeartbeat;
+}
+
+/**
+ * Instrumenta uma chamada ao Gemini API com timing e token tracking.
+ *
+ * @example
+ * ```ts
+ * import { monitorAI } from '@victor-studio/monitor/adapters/gemini'
+ *
+ * const result = await monitorAI(monitor, 'generate', () =>
+ *   model.generateContent(prompt),
+ *   { model: 'gemini-2.5-flash' },
+ * )
+ * ```
+ */
+declare function monitorAI<T>(monitor: MonitorClient, operation: string, fn: () => Promise<T>, meta?: Record<string, string>): Promise<T>;
+/**
+ * Instrumenta uma chamada AI e extrai token usage do resultado.
+ * Específico para o formato de resposta do Google Generative AI SDK.
+ *
+ * @example
+ * ```ts
+ * const result = await monitorAIWithTokens(monitor, 'generate', async () => {
+ *   const res = await model.generateContent(prompt)
+ *   return {
+ *     result: res,
+ *     inputTokens: res.response.usageMetadata?.promptTokenCount,
+ *     outputTokens: res.response.usageMetadata?.candidatesTokenCount,
+ *   }
+ * }, { model: 'gemini-2.5-flash' })
+ * ```
+ */
+declare function monitorAIWithTokens<T>(monitor: MonitorClient, operation: string, fn: () => Promise<{
+    result: T;
+    inputTokens?: number;
+    outputTokens?: number;
+}>, meta?: Record<string, string>): Promise<T>;
+
+export { monitorAI, monitorAIWithTokens };

package/dist/adapters/gemini/gemini.js

@@ -0,0 +1,62 @@
+// src/adapters/core.ts
+async function withTiming(monitor, adapter, operation, fn, meta) {
+  const start = performance.now();
+  try {
+    const result = await fn();
+    monitor.trackAdapter({
+      adapter,
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: true,
+      meta
+    });
+    return result;
+  } catch (error) {
+    monitor.trackAdapter({
+      adapter,
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      meta
+    });
+    throw error;
+  }
+}
+
+// src/adapters/gemini.ts
+function monitorAI(monitor, operation, fn, meta) {
+  return withTiming(monitor, "gemini", operation, fn, meta);
+}
+async function monitorAIWithTokens(monitor, operation, fn, meta) {
+  const start = performance.now();
+  try {
+    const { result, inputTokens, outputTokens } = await fn();
+    monitor.trackAdapter({
+      adapter: "gemini",
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: true,
+      meta: {
+        ...meta,
+        ...inputTokens !== void 0 ? { inputTokens: String(inputTokens) } : {},
+        ...outputTokens !== void 0 ? { outputTokens: String(outputTokens) } : {}
+      }
+    });
+    return result;
+  } catch (error) {
+    monitor.trackAdapter({
+      adapter: "gemini",
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      meta
+    });
+    throw error;
+  }
+}
+
+export { monitorAI, monitorAIWithTokens };
+//# sourceMappingURL=gemini.js.map
+//# sourceMappingURL=gemini.js.map

package/dist/adapters/gemini/gemini.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/core.ts","../../../src/adapters/gemini.ts"],"names":[],"mappings":";AAgBA,eAAsB,UAAA,CACpB,OAAA,EACA,OAAA,EACA,SAAA,EACA,IACA,IAAA,EACY;AACZ,EAAA,MAAM,KAAA,GAAQ,YAAY,GAAA,EAAI;AAE9B,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,MAAM,EAAA,EAAG;AAExB,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,IAAA;AAAA,MACT;AAAA,KACqB,CAAA;AAEvB,IAAA,OAAO,MAAA;AAAA,EACT,SAAS,KAAA,EAAO;AACd,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,KAAA;AAAA,MACT,OAAO,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU,OAAO,KAAK,CAAA;AAAA,MAC5D;AAAA,KACqB,CAAA;AAEvB,IAAA,MAAM,KAAA;AAAA,EACR;AACF;;;AC/BO,SAAS,SAAA,CACd,OAAA,EACA,SAAA,EACA,EAAA,EACA,IAAA,EACY;AACZ,EAAA,OAAO,UAAA,CAAW,OAAA,EAAS,QAAA,EAAU,SAAA,EAAW,IAAI,IAAI,CAAA;AAC1D;AAkBA,eAAsB,mBAAA,CACpB,OAAA,EACA,SAAA,EACA,EAAA,EACA,IAAA,EACY;AACZ,EAAA,MAAM,KAAA,GAAQ,YAAY,GAAA,EAAI;AAE9B,EAAA,IAAI;AACF,IAAA,MAAM,EAAE,MAAA,EAAQ,WAAA,EAAa,YAAA,EAAa,GAAI,MAAM,EAAA,EAAG;AAEvD,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA,EAAS,QAAA;AAAA,MACT,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,IAAA;AAAA,MACT,IAAA,EAAM;AAAA,QACJ,GAAG,IAAA;AAAA,QACH,GAAI,gBAAgB,KAAA,CAAA,GAAY,EAAE,aAAa,MAAA,CAAO,WAAW,CAAA,EAAE,GAAI,EAAC;AAAA,QACxE,GAAI,iBAAiB,KAAA,CAAA,GAAY,EAAE,cAAc,MAAA,CAAO,YAAY,CAAA,EAAE,GAAI;AAAC;AAC7E,KACD,CAAA;AAED,IAAA,OAAO,MAAA;AAAA,EACT,SAAS,KAAA,EAAO;AACd,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA,EAAS,QAAA;AAAA,MACT,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,KAAA;AAAA,MACT,OAAO,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU,OAAO,KAAK,CAAA;AAAA,MAC5D;AAAA,KACD,CAAA;AAED,IAAA,MAAM,KAAA;AAAA,EACR;AACF","file":"gemini.js","sourcesContent":["// Adapter core — utilitário genérico de instrumentação\n\nimport type { MonitorClient } from '../core/client'\nimport type { AdapterData } from '../types'\n\n/**\n * Mede a duração de uma operação assíncrona e reporta ao monitor.\n * Utilitário base usado por todos os adapters.\n *\n * @example\n * ```ts\n * const result = await withTiming(monitor, 'neon', 'query', () =>\n *   db.select().from(users),\n * )\n * ```\n */\nexport async function withTiming<T>(\n  monitor: MonitorClient,\n  adapter: string,\n  operation: string,\n  fn: () => Promise<T>,\n  meta?: Record<string, string>,\n): Promise<T> {\n  const start = performance.now()\n\n  try {\n    const result = await fn()\n\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: true,\n      meta,\n    } satisfies AdapterData)\n\n    return result\n  } catch (error) {\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      meta,\n    } satisfies AdapterData)\n\n    throw error // nunca engolir erros\n  }\n}\n\n/**\n * Versão sync do withTiming para operações síncronas.\n */\nexport function withTimingSync<T>(\n  monitor: MonitorClient,\n  adapter: string,\n  operation: string,\n  fn: () => T,\n  meta?: Record<string, string>,\n): T {\n  const start = performance.now()\n\n  try {\n    const result = fn()\n\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: true,\n      meta,\n    } satisfies AdapterData)\n\n    return result\n  } catch (error) {\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      meta,\n    } satisfies AdapterData)\n\n    throw error\n  }\n}\n","// Adapter Gemini — instrumentação de chamadas AI\n\nimport type { MonitorClient } from '../core/client'\nimport { withTiming } from './core'\n\n/**\n * Instrumenta uma chamada ao Gemini API com timing e token tracking.\n *\n * @example\n * ```ts\n * import { monitorAI } from '@victor-studio/monitor/adapters/gemini'\n *\n * const result = await monitorAI(monitor, 'generate', () =>\n *   model.generateContent(prompt),\n *   { model: 'gemini-2.5-flash' },\n * )\n * ```\n */\nexport function monitorAI<T>(\n  monitor: MonitorClient,\n  operation: string,\n  fn: () => Promise<T>,\n  meta?: Record<string, string>,\n): Promise<T> {\n  return withTiming(monitor, 'gemini', operation, fn, meta)\n}\n\n/**\n * Instrumenta uma chamada AI e extrai token usage do resultado.\n * Específico para o formato de resposta do Google Generative AI SDK.\n *\n * @example\n * ```ts\n * const result = await monitorAIWithTokens(monitor, 'generate', async () => {\n *   const res = await model.generateContent(prompt)\n *   return {\n *     result: res,\n *     inputTokens: res.response.usageMetadata?.promptTokenCount,\n *     outputTokens: res.response.usageMetadata?.candidatesTokenCount,\n *   }\n * }, { model: 'gemini-2.5-flash' })\n * ```\n */\nexport async function monitorAIWithTokens<T>(\n  monitor: MonitorClient,\n  operation: string,\n  fn: () => Promise<{ result: T; inputTokens?: number; outputTokens?: number }>,\n  meta?: Record<string, string>,\n): Promise<T> {\n  const start = performance.now()\n\n  try {\n    const { result, inputTokens, outputTokens } = await fn()\n\n    monitor.trackAdapter({\n      adapter: 'gemini',\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: true,\n      meta: {\n        ...meta,\n        ...(inputTokens !== undefined ? { inputTokens: String(inputTokens) } : {}),\n        ...(outputTokens !== undefined ? { outputTokens: String(outputTokens) } : {}),\n      },\n    })\n\n    return result\n  } catch (error) {\n    monitor.trackAdapter({\n      adapter: 'gemini',\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      meta,\n    })\n\n    throw error\n  }\n}\n"]}

package/dist/adapters/index.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+// src/adapters/core.ts
+async function withTiming(monitor, adapter, operation, fn, meta) {
+  const start = performance.now();
+  try {
+    const result = await fn();
+    monitor.trackAdapter({
+      adapter,
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: true,
+      meta
+    });
+    return result;
+  } catch (error) {
+    monitor.trackAdapter({
+      adapter,
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      meta
+    });
+    throw error;
+  }
+}
+function withTimingSync(monitor, adapter, operation, fn, meta) {
+  const start = performance.now();
+  try {
+    const result = fn();
+    monitor.trackAdapter({
+      adapter,
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: true,
+      meta
+    });
+    return result;
+  } catch (error) {
+    monitor.trackAdapter({
+      adapter,
+      operation,
+      durationMs: Math.round(performance.now() - start),
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      meta
+    });
+    throw error;
+  }
+}
+
+exports.withTiming = withTiming;
+exports.withTimingSync = withTimingSync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/adapters/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/core.ts"],"names":[],"mappings":";;;AAgBA,eAAsB,UAAA,CACpB,OAAA,EACA,OAAA,EACA,SAAA,EACA,IACA,IAAA,EACY;AACZ,EAAA,MAAM,KAAA,GAAQ,YAAY,GAAA,EAAI;AAE9B,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,MAAM,EAAA,EAAG;AAExB,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,IAAA;AAAA,MACT;AAAA,KACqB,CAAA;AAEvB,IAAA,OAAO,MAAA;AAAA,EACT,SAAS,KAAA,EAAO;AACd,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,KAAA;AAAA,MACT,OAAO,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU,OAAO,KAAK,CAAA;AAAA,MAC5D;AAAA,KACqB,CAAA;AAEvB,IAAA,MAAM,KAAA;AAAA,EACR;AACF;AAKO,SAAS,cAAA,CACd,OAAA,EACA,OAAA,EACA,SAAA,EACA,IACA,IAAA,EACG;AACH,EAAA,MAAM,KAAA,GAAQ,YAAY,GAAA,EAAI;AAE9B,EAAA,IAAI;AACF,IAAA,MAAM,SAAS,EAAA,EAAG;AAElB,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,IAAA;AAAA,MACT;AAAA,KACqB,CAAA;AAEvB,IAAA,OAAO,MAAA;AAAA,EACT,SAAS,KAAA,EAAO;AACd,IAAA,OAAA,CAAQ,YAAA,CAAa;AAAA,MACnB,OAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAY,IAAA,CAAK,KAAA,CAAM,WAAA,CAAY,GAAA,KAAQ,KAAK,CAAA;AAAA,MAChD,OAAA,EAAS,KAAA;AAAA,MACT,OAAO,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU,OAAO,KAAK,CAAA;AAAA,MAC5D;AAAA,KACqB,CAAA;AAEvB,IAAA,MAAM,KAAA;AAAA,EACR;AACF","file":"index.cjs","sourcesContent":["// Adapter core — utilitário genérico de instrumentação\n\nimport type { MonitorClient } from '../core/client'\nimport type { AdapterData } from '../types'\n\n/**\n * Mede a duração de uma operação assíncrona e reporta ao monitor.\n * Utilitário base usado por todos os adapters.\n *\n * @example\n * ```ts\n * const result = await withTiming(monitor, 'neon', 'query', () =>\n *   db.select().from(users),\n * )\n * ```\n */\nexport async function withTiming<T>(\n  monitor: MonitorClient,\n  adapter: string,\n  operation: string,\n  fn: () => Promise<T>,\n  meta?: Record<string, string>,\n): Promise<T> {\n  const start = performance.now()\n\n  try {\n    const result = await fn()\n\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: true,\n      meta,\n    } satisfies AdapterData)\n\n    return result\n  } catch (error) {\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      meta,\n    } satisfies AdapterData)\n\n    throw error // nunca engolir erros\n  }\n}\n\n/**\n * Versão sync do withTiming para operações síncronas.\n */\nexport function withTimingSync<T>(\n  monitor: MonitorClient,\n  adapter: string,\n  operation: string,\n  fn: () => T,\n  meta?: Record<string, string>,\n): T {\n  const start = performance.now()\n\n  try {\n    const result = fn()\n\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: true,\n      meta,\n    } satisfies AdapterData)\n\n    return result\n  } catch (error) {\n    monitor.trackAdapter({\n      adapter,\n      operation,\n      durationMs: Math.round(performance.now() - start),\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      meta,\n    } satisfies AdapterData)\n\n    throw error\n  }\n}\n"]}

package/dist/adapters/index.d.cts

@@ -0,0 +1,154 @@
+interface HeartbeatData {
+    status: 'online' | 'offline';
+    latencyMs: number;
+}
+interface RequestData {
+    method: string;
+    route: string;
+    statusCode: number;
+    responseTimeMs: number;
+    userAgent?: string;
+    region?: string;
+}
+interface VitalData {
+    name: 'LCP' | 'INP' | 'CLS' | 'FCP' | 'TTFB';
+    value: number;
+    rating: 'good' | 'needs-improvement' | 'poor';
+    page?: string;
+    deviceType?: string;
+    browser?: string;
+}
+interface ErrorData {
+    type: 'unhandled' | 'caught' | 'promise';
+    message: string;
+    stack?: string;
+    groupingKey: string;
+    route?: string;
+    method?: string;
+    statusCode?: number;
+    environment?: string;
+    commitHash?: string;
+    extra?: Record<string, string>;
+}
+interface DeployData {
+    commitHash: string;
+    branch?: string;
+    author?: string;
+    status: 'started' | 'succeeded' | 'failed';
+    buildDurationMs?: number;
+    url?: string;
+    environment?: string;
+    provider?: string;
+}
+interface AdapterData {
+    adapter: string;
+    operation: string;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+    meta?: Record<string, string>;
+}
+type MonitorEvent = {
+    type: 'heartbeat';
+    data: HeartbeatData;
+    timestamp: string;
+} | {
+    type: 'request';
+    data: RequestData;
+    timestamp: string;
+} | {
+    type: 'vital';
+    data: VitalData;
+    timestamp: string;
+} | {
+    type: 'error';
+    data: ErrorData;
+    timestamp: string;
+} | {
+    type: 'deploy';
+    data: DeployData;
+    timestamp: string;
+} | {
+    type: 'adapter';
+    data: AdapterData;
+    timestamp: string;
+};
+/** Hook para filtrar/modificar eventos antes do envio */
+type BeforeSendHook = (event: MonitorEvent) => MonitorEvent | null;
+
+interface MonitorConfig {
+    /** ID do projeto no Nuvio */
+    projectId: string;
+    /** API key gerada no Nuvio */
+    apiKey: string;
+    /** URL do endpoint de ingest */
+    endpoint: string;
+    /** Intervalo do heartbeat em ms (default: 60000) */
+    heartbeatInterval?: number;
+    /** Intervalo do flush do buffer em ms (default: 30000) */
+    flushInterval?: number;
+    /** Timeout do fetch em ms (default: 10000) */
+    timeout?: number;
+    /** Max tentativas de retry (default: 3) */
+    maxRetries?: number;
+    /** Desabilitar em desenvolvimento (default: true) */
+    disableInDev?: boolean;
+    /** Taxa de amostragem 0.0-1.0 (default: 1.0). Heartbeats nunca são amostrados */
+    sampleRate?: number;
+    /** Hook chamado antes de enfileirar cada evento. Retorna null para dropar */
+    beforeSend?: BeforeSendHook;
+    /** Habilitar logs de debug no console (default: false) */
+    debug?: boolean;
+    /** Capturar erros globais automaticamente — window.onerror (default: false) */
+    captureErrors?: boolean;
+    /** Capturar unhandled promise rejections automaticamente (default: false) */
+    captureUnhandledRejections?: boolean;
+}
+declare class MonitorClient {
+    readonly config: MonitorConfig;
+    private readonly collector;
+    private readonly logger;
+    private heartbeatTimer;
+    private globalHandlersCleanup;
+    private active;
+    constructor(config: MonitorConfig);
+    /** Inicia o monitoring (heartbeat + collector) */
+    start(): void;
+    /** Para o monitoring */
+    stop(): void;
+    /** Força um flush imediato do buffer */
+    flush(): void;
+    /** Verifica se o monitoring está ativo */
+    get isActive(): boolean;
+    /** Registra um evento de request HTTP (usado pelo middleware) */
+    trackRequest(data: RequestData): void;
+    /** Registra um Web Vital (usado pelo MonitorScript) */
+    trackVital(data: VitalData): void;
+    /** Registra um evento de adapter (DB, cache, AI, queue, email) */
+    trackAdapter(data: AdapterData): void;
+    /** Registra um erro capturado */
+    captureError(data: ErrorData): void;
+    /** Registra um evento de deploy */
+    trackDeploy(data: DeployData): void;
+    private startHeartbeat;
+    private sendHeartbeat;
+}
+
+/**
+ * Mede a duração de uma operação assíncrona e reporta ao monitor.
+ * Utilitário base usado por todos os adapters.
+ *
+ * @example
+ * ```ts
+ * const result = await withTiming(monitor, 'neon', 'query', () =>
+ *   db.select().from(users),
+ * )
+ * ```
+ */
+declare function withTiming<T>(monitor: MonitorClient, adapter: string, operation: string, fn: () => Promise<T>, meta?: Record<string, string>): Promise<T>;
+/**
+ * Versão sync do withTiming para operações síncronas.
+ */
+declare function withTimingSync<T>(monitor: MonitorClient, adapter: string, operation: string, fn: () => T, meta?: Record<string, string>): T;
+
+export { withTiming, withTimingSync };