@moonwatch/js 0.1.8

package/dist/index.d.ts

@@ -0,0 +1,132 @@
+type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL';
+interface LoggerConfig {
+    logId: string;
+    apiKey?: string;
+    group?: string;
+    /** Only send logs at this level and above to the remote service (default: 'DEBUG' — sends everything) */
+    level?: LogLevel;
+    onError?: (error: Error, logs: InternalLogEntry[]) => void;
+    traceId?: string;
+    /** When true, skip console output from logger.* methods; default false */
+    silent?: boolean;
+    /** When true, log SDK internal operations to console for troubleshooting */
+    debug?: boolean;
+    /** @internal Override base URL for development (e.g. 'http://localhost:3500') */
+    _endpoint?: string;
+    /** @internal Override WebSocket base URL for development (e.g. 'ws://localhost:3501') */
+    _wsEndpoint?: string;
+    /** @internal Full URL for log ingestion proxy (e.g. '/api/internal/ingest'). When set, uses this as the POST URL directly (no /ingest/http appended), skips WebSocket. */
+    _ingestUrl?: string;
+}
+interface InternalLogEntry {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    logId: string;
+    group?: string;
+    trace_id?: string;
+    stack?: string;
+    error_type?: string;
+    release_id?: string;
+    watcher_id?: string;
+    metadata?: Record<string, unknown>;
+}
+/** Object form for logger.info({ message, group?, metadata? }) */
+interface LogEntryObject {
+    message: string;
+    group?: string;
+    traceId?: string;
+    watcherId?: string;
+    metadata?: Record<string, unknown>;
+}
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'failed';
+declare class Logger {
+    private config;
+    private baseUrl;
+    private httpIngestUrl;
+    private wsIngestUrl;
+    private proxyMode;
+    private buffer;
+    private flushTimer;
+    private flushPromise;
+    private consoleIntercepted;
+    private httpBackoffMs;
+    private maxBackoffMs;
+    private consecutiveHttpFailures;
+    private _onError;
+    private _onUnhandledRejection;
+    private ws;
+    private wsState;
+    private wsReconnectTimer;
+    private wsReconnectAttempts;
+    private maxWsReconnectAttempts;
+    private _onVisibilityChange;
+    private _onBeforeUnload;
+    constructor(config: LoggerConfig);
+    private debugLog;
+    private connectWebSocket;
+    private startFlushTimer;
+    private shouldLog;
+    private formatArgs;
+    private static readonly CONSOLE_METHOD;
+    private log;
+    private parseArgs;
+    debug(entry: LogEntryObject): void;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(entry: LogEntryObject): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(entry: LogEntryObject): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(entry: LogEntryObject): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    error(err: Error, metadata?: Record<string, unknown>): void;
+    fatal(entry: LogEntryObject): void;
+    fatal(message: string, metadata?: Record<string, unknown>): void;
+    fatal(err: Error, metadata?: Record<string, unknown>): void;
+    withTraceId(traceId: string): ScopedLogger;
+    withGroup(group: string): ScopedLogger;
+    withWatcher(watcherId: string): ScopedLogger;
+    setTraceId(traceId: string | undefined): void;
+    setGroup(group: string | undefined): void;
+    interceptConsole(group?: string, options?: {
+        wrapErrors?: boolean;
+    }): void;
+    restoreConsole(): void;
+    flush(): Promise<void>;
+    private doFlush;
+    private sendViaWebSocket;
+    private sendViaHttp;
+    /** Fire-and-forget flush using fetch with keepalive (works during page unload) */
+    private flushSync;
+    private registerLifecycleHooks;
+    /** Check server connectivity and API key validity */
+    ping(): Promise<{
+        ok: boolean;
+        latencyMs: number;
+        error?: string;
+    }>;
+    /** Get current connection status */
+    getConnectionStatus(): {
+        transport: 'websocket' | 'http';
+        state: ConnectionState;
+    };
+}
+declare class ScopedLogger {
+    private parent;
+    private group?;
+    private traceId?;
+    private watcherId?;
+    constructor(parent: Logger, group?: string | undefined, traceId?: string | undefined, watcherId?: string | undefined);
+    withGroup(group: string): ScopedLogger;
+    withTraceId(traceId: string): ScopedLogger;
+    withWatcher(watcherId: string): ScopedLogger;
+    private opts;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    fatal(message: string, metadata?: Record<string, unknown>): void;
+}
+declare function createLogger(config: LoggerConfig): Logger;
+
+export { type InternalLogEntry, type LogEntryObject, type LogLevel, Logger, type LoggerConfig, createLogger, createLogger as default };