@duckbug/js 0.1.2 → 1.0.0

package/dist/esm/DuckBug/DuckBugService.js

@@ -1,24 +1,165 @@
+import { ingestErrorsBatchUrl, ingestErrorsUrl, ingestLogsBatchUrl, ingestLogsUrl, parseDuckBugIngestDsn } from "./parseDuckBugDsn.js";
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_RETRY_DELAY_MS = 200;
+const MAX_BACKEND_BATCH = 1000;
+function isRetriableHttpStatus(status) {
+    return 408 === status || 429 === status || 500 === status || 502 === status || 503 === status || 504 === status;
+}
+function ingestResponseAccepted(status) {
+    return status >= 200 && status < 300 || 409 === status;
+}
 class DuckBugService {
-    config;
+    logsUrl;
+    errorsUrl;
+    logsBatchUrl;
+    errorsBatchUrl;
+    maxBatchSize;
+    maxRetries;
+    retryDelayMs;
+    fetchImpl;
+    onTransportError;
+    logQueue = [];
+    errorQueue = [];
+    logChain = Promise.resolve();
+    errorChain = Promise.resolve();
     constructor(config){
-        this.config = config;
+        const parsed = parseDuckBugIngestDsn(config.dsn);
+        this.logsUrl = ingestLogsUrl(parsed);
+        this.errorsUrl = ingestErrorsUrl(parsed);
+        this.logsBatchUrl = ingestLogsBatchUrl(parsed);
+        this.errorsBatchUrl = ingestErrorsBatchUrl(parsed);
+        this.maxBatchSize = config.transport?.maxBatchSize ?? 1;
+        this.maxRetries = config.transport?.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.retryDelayMs = config.transport?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+        this.fetchImpl = config.transport?.fetchImpl ?? globalThis.fetch.bind(globalThis);
+        this.onTransportError = config.onTransportError;
     }
     sendLog(logInfo) {
-        fetch(`${this.config.dsn}/logs`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(logInfo)
+        this.enqueueLogTransport(async ()=>{
+            this.logQueue.push(logInfo);
+            await this.pumpLogsAfterEnqueue();
+        });
+    }
+    sendError(errorRequest) {
+        this.enqueueErrorTransport(async ()=>{
+            this.errorQueue.push(errorRequest);
+            await this.pumpErrorsAfterEnqueue();
+        });
+    }
+    flush() {
+        return Promise.all([
+            this.flushLogs(),
+            this.flushErrors()
+        ]).then(()=>{});
+    }
+    flushLogs() {
+        return this.enqueueLogTransport(async ()=>{
+            while(this.logQueue.length > 0)await this.drainLogStep();
+        });
+    }
+    flushErrors() {
+        return this.enqueueErrorTransport(async ()=>{
+            while(this.errorQueue.length > 0)await this.drainErrorStep();
         });
     }
-    sendError(errorInfo) {
-        fetch(`${this.config.dsn}/errors`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(errorInfo)
+    enqueueLogTransport(fn) {
+        const p = this.logChain.then(()=>fn());
+        this.logChain = p.then(()=>void 0, ()=>void 0);
+        return p;
+    }
+    enqueueErrorTransport(fn) {
+        const p = this.errorChain.then(()=>fn());
+        this.errorChain = p.then(()=>void 0, ()=>void 0);
+        return p;
+    }
+    async pumpLogsAfterEnqueue() {
+        if (this.maxBatchSize <= 1) {
+            const item = this.logQueue.shift();
+            if (item) await this.postJsonWithRetry(this.logsUrl, item, "log", 1);
+            return;
+        }
+        if (this.logQueue.length >= this.maxBatchSize) {
+            const n = Math.min(this.maxBatchSize, MAX_BACKEND_BATCH, this.logQueue.length);
+            const batch = this.logQueue.splice(0, n);
+            await this.postJsonWithRetry(this.logsBatchUrl, batch, "log", batch.length);
+        }
+    }
+    async pumpErrorsAfterEnqueue() {
+        if (this.maxBatchSize <= 1) {
+            const item = this.errorQueue.shift();
+            if (item) await this.postJsonWithRetry(this.errorsUrl, item, "error", 1);
+            return;
+        }
+        if (this.errorQueue.length >= this.maxBatchSize) {
+            const n = Math.min(this.maxBatchSize, MAX_BACKEND_BATCH, this.errorQueue.length);
+            const batch = this.errorQueue.splice(0, n);
+            await this.postJsonWithRetry(this.errorsBatchUrl, batch, "error", batch.length);
+        }
+    }
+    async drainLogStep() {
+        if (this.maxBatchSize <= 1) {
+            const item = this.logQueue.shift();
+            if (item) await this.postJsonWithRetry(this.logsUrl, item, "log", 1);
+            return;
+        }
+        const n = Math.min(this.maxBatchSize, MAX_BACKEND_BATCH, this.logQueue.length);
+        if (0 === n) return;
+        const batch = this.logQueue.splice(0, n);
+        await this.postJsonWithRetry(this.logsBatchUrl, batch, "log", batch.length);
+    }
+    async drainErrorStep() {
+        if (this.maxBatchSize <= 1) {
+            const item = this.errorQueue.shift();
+            if (item) await this.postJsonWithRetry(this.errorsUrl, item, "error", 1);
+            return;
+        }
+        const n = Math.min(this.maxBatchSize, MAX_BACKEND_BATCH, this.errorQueue.length);
+        if (0 === n) return;
+        const batch = this.errorQueue.splice(0, n);
+        await this.postJsonWithRetry(this.errorsBatchUrl, batch, "error", batch.length);
+    }
+    emitFailure(info) {
+        this.onTransportError?.(info);
+    }
+    async postJsonWithRetry(url, body, kind, itemCount) {
+        let lastErr = new Error("unknown transport failure");
+        const maxAttempts = this.maxRetries + 1;
+        for(let attempt = 0; attempt < maxAttempts; attempt++){
+            try {
+                const res = await this.fetchImpl(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify(body)
+                });
+                if (ingestResponseAccepted(res.status)) return;
+                let detail = "";
+                try {
+                    const t = await res.text();
+                    const trimmed = t.trim();
+                    if (trimmed) {
+                        const max = 400;
+                        detail = trimmed.length > max ? `${trimmed.slice(0, max)}\u{2026}` : trimmed;
+                    }
+                } catch  {}
+                lastErr = new Error(detail ? `ingest HTTP ${res.status}: ${detail}` : `ingest HTTP ${res.status}`);
+                if (!isRetriableHttpStatus(res.status)) break;
+            } catch (e) {
+                lastErr = e;
+            }
+            if (attempt < maxAttempts - 1) {
+                const delay = this.retryDelayMs * 2 ** attempt;
+                await new Promise((r)=>setTimeout(r, delay));
+            }
+        }
+        const message = lastErr instanceof Error ? lastErr.message : String(lastErr);
+        this.emitFailure({
+            kind,
+            itemCount,
+            attempts: maxAttempts,
+            error: lastErr,
+            message
         });
     }
 }

package/dist/esm/DuckBug/Pond.js

@@ -0,0 +1,10 @@
+const Pond = {
+    ripple (extraSensitiveKeys = []) {
+        return {
+            extraSensitiveKeys: [
+                ...extraSensitiveKeys
+            ]
+        };
+    }
+};
+export { Pond };

package/dist/esm/DuckBug/ensureEventId.js

@@ -0,0 +1,13 @@
+function randomEventId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID) return c.randomUUID();
+    throw new Error("crypto.randomUUID is not available; use a runtime with Web Crypto or set eventId on events explicitly");
+}
+function ensureEventId(event) {
+    if (void 0 !== event.eventId && "" !== event.eventId) return event;
+    return {
+        ...event,
+        eventId: randomEventId()
+    };
+}
+export { ensureEventId };

package/dist/esm/DuckBug/finalizeIngestEvent.js

@@ -0,0 +1,20 @@
+import { SDK_IDENTITY } from "../sdkIdentity.js";
+import { ensureEventId } from "./ensureEventId.js";
+import { sanitizeIngestPayload } from "./sanitizeIngestPayload.js";
+import { stripIngestSections } from "./stripIngestSections.js";
+function withDefaultSdk(event) {
+    if (void 0 !== event.sdk) return event;
+    return {
+        ...event,
+        sdk: {
+            ...SDK_IDENTITY
+        }
+    };
+}
+function finalizeIngestEvent(event, options = {}) {
+    const withSdk = withDefaultSdk(event);
+    const stripped = stripIngestSections(withSdk, options.stripSections);
+    const sanitized = sanitizeIngestPayload(stripped, options.extraSensitiveKeys);
+    return ensureEventId(sanitized);
+}
+export { finalizeIngestEvent };

package/dist/esm/DuckBug/index.js

@@ -1,2 +1,6 @@
 import { DuckBugProvider } from "./DuckBugProvider.js";
-export { DuckBugProvider };
+import { ensureEventId } from "./ensureEventId.js";
+import { finalizeIngestEvent } from "./finalizeIngestEvent.js";
+import { Pond } from "./Pond.js";
+import { stripIngestSections } from "./stripIngestSections.js";
+export { DuckBugProvider, Pond, ensureEventId, finalizeIngestEvent, stripIngestSections };

package/dist/esm/DuckBug/parseDuckBugDsn.js

@@ -0,0 +1,36 @@
+function parseDuckBugIngestDsn(dsn) {
+    let url;
+    try {
+        url = new URL(dsn);
+    } catch  {
+        throw new Error("Invalid DuckBug DSN: not a valid URL");
+    }
+    const match = url.pathname.match(/^((?:\/api)?\/ingest)\/([^/]+)$/);
+    if (!match) throw new Error("Invalid DuckBug DSN: path must be /ingest/{projectId}:{publicKey} or /api/ingest/{projectId}:{publicKey}");
+    const ingestPathPrefix = match[1];
+    const segment = match[2];
+    const colon = segment.indexOf(":");
+    if (colon <= 0 || colon === segment.length - 1) throw new Error("Invalid DuckBug DSN: ingest segment must be projectId:publicKey");
+    return {
+        origin: url.origin,
+        ingestPathPrefix,
+        projectId: segment.slice(0, colon),
+        key: segment.slice(colon + 1)
+    };
+}
+function ingestBase(parsed) {
+    return `${parsed.origin}${parsed.ingestPathPrefix}/${parsed.projectId}:${parsed.key}`;
+}
+function ingestLogsUrl(parsed) {
+    return `${ingestBase(parsed)}/logs`;
+}
+function ingestErrorsUrl(parsed) {
+    return `${ingestBase(parsed)}/errors`;
+}
+function ingestLogsBatchUrl(parsed) {
+    return `${ingestBase(parsed)}/logs/batch`;
+}
+function ingestErrorsBatchUrl(parsed) {
+    return `${ingestBase(parsed)}/errors/batch`;
+}
+export { ingestErrorsBatchUrl, ingestErrorsUrl, ingestLogsBatchUrl, ingestLogsUrl, parseDuckBugIngestDsn };

package/dist/esm/DuckBug/sanitizeIngestPayload.js

@@ -0,0 +1,33 @@
+const DEFAULT_SENSITIVE_KEYS = new Set([
+    "password",
+    "token",
+    "api_key",
+    "authorization",
+    "cookie",
+    "session",
+    "secret"
+]);
+const MASK = "***";
+function normalizeKey(key) {
+    return key.trim().toLowerCase().replace(/-/g, "_").replace(/\s+/g, "_");
+}
+function isSensitive(key, extra) {
+    const n = normalizeKey(key);
+    if (DEFAULT_SENSITIVE_KEYS.has(n)) return true;
+    for (const e of extra)if (normalizeKey(e) === n) return true;
+    return false;
+}
+function cloneValue(value, extraSensitive, depth) {
+    if (depth > 20) return value;
+    if (null === value || "object" != typeof value) return value;
+    if (Array.isArray(value)) return value.map((v)=>cloneValue(v, extraSensitive, depth + 1));
+    const out = {};
+    for (const [k, v] of Object.entries(value))if (isSensitive(k, extraSensitive)) out[k] = MASK;
+    else out[k] = cloneValue(v, extraSensitive, depth + 1);
+    return out;
+}
+function sanitizeIngestPayload(payload, extraSensitiveKeys) {
+    const extra = new Set(extraSensitiveKeys ?? []);
+    return cloneValue(JSON.parse(JSON.stringify(payload)), extra, 0);
+}
+export { sanitizeIngestPayload };

package/dist/esm/DuckBug/stripIngestSections.js

@@ -0,0 +1,9 @@
+function stripIngestSections(event, sections) {
+    if (void 0 === sections || 0 === sections.length) return event;
+    const o = {
+        ...event
+    };
+    for (const s of sections)delete o[s];
+    return o;
+}
+export { stripIngestSections };

package/dist/esm/SDK/DuckSDK.js

@@ -1,28 +1,144 @@
-import { LogProvider, logLevel } from "./index.js";
+import { processError } from "../DuckBug/DuckBugHelper.js";
+import { finalizeIngestEvent } from "../DuckBug/finalizeIngestEvent.js";
+import { SDK_IDENTITY } from "../sdkIdentity.js";
+import { logLevel } from "./LogLevel.js";
+import { LogProvider } from "./LogProvider.js";
+function isPromiseLike(v) {
+    return null !== v && "object" == typeof v && "then" in v && "function" == typeof v.then;
+}
 class DuckSDK {
     providers;
-    constructor(providers, logProviderConfig){
+    scope = {};
+    beforeSendHook;
+    extraSensitiveKeys;
+    stripSections;
+    constructor(providers, logProviderConfig, options){
         this.providers = providers;
+        this.beforeSendHook = options?.beforeSend;
+        this.extraSensitiveKeys = options?.extraSensitiveKeys;
+        this.stripSections = options?.stripSections;
         new LogProvider(providers, logProviderConfig);
     }
+    setScope(scope) {
+        this.scope = {
+            ...this.scope,
+            ...scope
+        };
+    }
+    flush() {
+        return Promise.all(this.providers.map((p)=>{
+            const f = p.flush;
+            return f ? Promise.resolve(f.call(p)) : Promise.resolve();
+        })).then(()=>void 0);
+    }
     log(tag, payload) {
-        this.sendReportToPlugins(tag, logLevel.DEBUG, payload);
+        this.emitLog(logLevel.DEBUG, tag, payload);
     }
     error(tag, payload) {
-        this.sendReportToPlugins(tag, logLevel.DEBUG, payload);
+        this.emitLog(logLevel.ERROR, tag, payload);
     }
     debug(tag, payload) {
-        this.sendReportToPlugins(tag, logLevel.DEBUG, payload);
+        this.emitLog(logLevel.DEBUG, tag, payload);
     }
     warn(tag, payload) {
-        this.sendReportToPlugins(tag, logLevel.WARN, payload);
+        this.emitLog(logLevel.WARN, tag, payload);
     }
     fatal(tag, payload) {
-        this.sendReportToPlugins(tag, logLevel.FATAL, payload);
+        this.emitLog(logLevel.FATAL, tag, payload);
+    }
+    quack(tag, error) {
+        const time = Date.now();
+        const built = processError(error, tag, time);
+        const merged = this.mergeScope(built);
+        const finalized = finalizeIngestEvent(merged, {
+            extraSensitiveKeys: this.extraSensitiveKeys,
+            stripSections: this.stripSections
+        });
+        if (!this.beforeSendHook) {
+            for (const p of this.providers)p.sendError(finalized, {
+                skipPrivacyPipeline: true
+            });
+            return;
+        }
+        const arg = {
+            kind: "error",
+            event: finalized
+        };
+        const out = this.beforeSendHook(arg);
+        if (isPromiseLike(out)) return void out.then((resolved)=>{
+            const after = this.normalizeBeforeSendError(resolved, finalized);
+            if (null === after) return;
+            for (const p of this.providers)p.sendError(after, {
+                skipPrivacyPipeline: true
+            });
+        });
+        const after = this.normalizeBeforeSendError(out, finalized);
+        if (null === after) return;
+        for (const p of this.providers)p.sendError(after, {
+            skipPrivacyPipeline: true
+        });
+    }
+    normalizeBeforeSendLog(out, fallback) {
+        if (null === out) return null;
+        if (void 0 === out) return fallback;
+        return out;
     }
-    quack() {}
-    sendReportToPlugins(tag, level, payload) {
-        this.providers.forEach((plugin)=>plugin.report(tag, level, payload));
+    normalizeBeforeSendError(out, fallback) {
+        if (null === out) return null;
+        if (void 0 === out) return fallback;
+        return out;
+    }
+    emitLog(level, message, payload) {
+        const event = this.mergeScope({
+            time: Date.now(),
+            level,
+            message,
+            platform: "node",
+            sdk: {
+                ...SDK_IDENTITY
+            },
+            ...void 0 !== payload ? {
+                context: payload
+            } : {}
+        });
+        const finalized = finalizeIngestEvent(event, {
+            extraSensitiveKeys: this.extraSensitiveKeys,
+            stripSections: this.stripSections
+        });
+        if (!this.beforeSendHook) {
+            for (const p of this.providers)p.sendLog(finalized, {
+                skipPrivacyPipeline: true
+            });
+            return;
+        }
+        const arg = {
+            kind: "log",
+            event: finalized
+        };
+        const out = this.beforeSendHook(arg);
+        if (isPromiseLike(out)) return void out.then((resolved)=>{
+            const after = this.normalizeBeforeSendLog(resolved, finalized);
+            if (null === after) return;
+            for (const p of this.providers)p.sendLog(after, {
+                skipPrivacyPipeline: true
+            });
+        });
+        const after = this.normalizeBeforeSendLog(out, finalized);
+        if (null === after) return;
+        for (const p of this.providers)p.sendLog(after, {
+            skipPrivacyPipeline: true
+        });
+    }
+    mergeScope(event) {
+        return {
+            ...this.scope,
+            ...event
+        };
+    }
+}
+class Duck extends DuckSDK {
+    captureException(error, tag) {
+        this.quack(tag ?? "error", error);
     }
 }
-export { DuckSDK };
+export { Duck, DuckSDK };

package/dist/esm/SDK/index.js

@@ -1,4 +1,4 @@
-import { DuckSDK } from "./DuckSDK.js";
+import { Duck, DuckSDK } from "./DuckSDK.js";
 import { logLevel } from "./LogLevel.js";
 import { LogProvider } from "./LogProvider.js";
-export { DuckSDK, LogProvider, logLevel };
+export { Duck, DuckSDK, LogProvider, logLevel };

package/dist/esm/index.js

@@ -1,2 +1,4 @@
+export * from "./contract/index.js";
 export * from "./DuckBug/index.js";
+export * from "./integrations/node.js";
 export * from "./SDK/index.js";

package/dist/esm/integrations/node.js

@@ -0,0 +1,20 @@
+function registerNodeGlobalErrorHandlers(options) {
+    const rejectionTag = options.rejectionTag ?? "unhandledRejection";
+    const exceptionTag = options.exceptionTag ?? "uncaughtException";
+    const onRejection = (reason)=>{
+        const err = reason instanceof Error ? reason : new Error("string" == typeof reason ? reason : JSON.stringify(reason));
+        options.duck.quack(rejectionTag, err);
+        options.duck.flush();
+    };
+    const onException = (err)=>{
+        options.duck.quack(exceptionTag, err);
+        options.duck.flush();
+    };
+    process.on("unhandledRejection", onRejection);
+    process.on("uncaughtException", onException);
+    return ()=>{
+        process.off("unhandledRejection", onRejection);
+        process.off("uncaughtException", onException);
+    };
+}
+export { registerNodeGlobalErrorHandlers };

package/dist/esm/sdkIdentity.js

@@ -0,0 +1,7 @@
+const SDK_NAME = "@duckbug/js";
+const SDK_VERSION = "0.1.3";
+const SDK_IDENTITY = {
+    name: SDK_NAME,
+    version: SDK_VERSION
+};
+export { SDK_IDENTITY, SDK_NAME, SDK_VERSION };

package/dist/types/DuckBug/DuckBugConfig.d.ts

@@ -1,3 +1,31 @@
+import type { DuckBugErrorEvent, DuckBugLogEvent } from "../contract";
+import type { StrippableIngestSection } from "./stripIngestSections";
+import type { TransportFailureInfo } from "./transportTypes";
+export type BeforeSendIngestArg = {
+    kind: "log";
+    event: DuckBugLogEvent;
+} | {
+    kind: "error";
+    event: DuckBugErrorEvent;
+};
+export type BeforeSendIngestResult = DuckBugLogEvent | DuckBugErrorEvent | null | undefined;
+export type DuckBugTransportConfig = {
+    /** When <= 1, each event is POSTed to single-event ingest. When > 1, batches use /batch until flush. Default 1. */
+    maxBatchSize?: number;
+    maxRetries?: number;
+    /** Base delay; attempts use exponential backoff from this value. */
+    retryDelayMs?: number;
+    fetchImpl?: typeof fetch;
+};
 export type DuckBugConfig = {
     dsn: string;
+    extraSensitiveKeys?: string[];
+    stripSections?: StrippableIngestSection[];
+    /**
+     * Runs after strip/sanitize/eventId for direct `DuckBugProvider` sends.
+     * When using `DuckSDK`, prefer `DuckSDK` constructor `beforeSend`.
+     */
+    beforeSend?: (arg: BeforeSendIngestArg) => BeforeSendIngestResult | Promise<BeforeSendIngestResult>;
+    transport?: DuckBugTransportConfig;
+    onTransportError?: (info: TransportFailureInfo) => void;
 };

package/dist/types/DuckBug/DuckBugHelper.d.ts

@@ -0,0 +1,22 @@
+import type { DuckBugErrorEvent } from "../contract";
+export type StacktraceFrame = {
+    index: number;
+    content: string;
+};
+export type Stacktrace = {
+    raw: string;
+    frames: StacktraceFrame[];
+};
+type ParsedError = {
+    file: string;
+    line: number;
+    stacktrace: Stacktrace;
+    context: unknown;
+};
+export declare function parseError(error: Error): ParsedError;
+/**
+ * Builds a canonical DuckBug error event: {@link error.message} is the primary
+ * `message` field; `tag` is sent as `dTags` for grouping/search.
+ */
+export declare function processError(error: Error, tag: string, time: number): DuckBugErrorEvent;
+export {};

package/dist/types/DuckBug/DuckBugProvider.d.ts

@@ -1,14 +1,25 @@
-import { type LogLevel, type Provider } from "../SDK";
+import type { DuckBugErrorEvent, DuckBugLogEvent } from "../contract";
+import { type LogLevel, type Provider, type SendEventMeta } from "../SDK";
 import type { DuckBugConfig } from "./DuckBugConfig";
 import { DuckBugService } from "./DuckBugService";
 export declare class DuckBugProvider implements Provider {
     service: DuckBugService;
+    private readonly ingestConfig;
     constructor(config: DuckBugConfig);
+    static fromDSN(dsn: string): DuckBugProvider;
+    /** Drains the ingest transport queue; safe to call multiple times. */
+    flush(): Promise<void>;
+    sendLog(event: DuckBugLogEvent, meta?: SendEventMeta): void;
+    sendError(event: DuckBugErrorEvent, meta?: SendEventMeta): void;
+    private sendLogAsync;
+    private sendErrorAsync;
     warn(...args: unknown[]): void;
     error(...args: unknown[]): void;
     log(...args: unknown[]): void;
+    /** @deprecated Prefer {@link Duck} logging methods; kept for direct provider use. */
     report(tag: string, level: LogLevel, payload?: object): void;
     quack(tag: string, error: Error): void;
+    private normalizedContextPayload;
     private convertArgsToString;
     private getTimeStamp;
 }

package/dist/types/DuckBug/DuckBugService.d.ts

@@ -1,12 +1,34 @@
+import type { DuckBugErrorEvent, DuckBugLogEvent } from "../contract";
 import type { DuckBugConfig } from "./DuckBugConfig";
-import type { Log } from "./Log";
+/** @deprecated Use {@link DuckBugErrorEvent} from the public contract types. */
+export type ErrorRequest = DuckBugErrorEvent;
 export declare class DuckBugService {
-    private config;
+    private readonly logsUrl;
+    private readonly errorsUrl;
+    private readonly logsBatchUrl;
+    private readonly errorsBatchUrl;
+    private readonly maxBatchSize;
+    private readonly maxRetries;
+    private readonly retryDelayMs;
+    private readonly fetchImpl;
+    private readonly onTransportError?;
+    private readonly logQueue;
+    private readonly errorQueue;
+    private logChain;
+    private errorChain;
     constructor(config: DuckBugConfig);
-    sendLog(logInfo: Log): void;
-    sendError(errorInfo: {
-        message: string;
-        stack?: string;
-        context: string;
-    }): void;
+    sendLog(logInfo: DuckBugLogEvent): void;
+    sendError(errorRequest: DuckBugErrorEvent): void;
+    /** Drains queued events for both logs and errors. Safe to call multiple times. */
+    flush(): Promise<void>;
+    private flushLogs;
+    private flushErrors;
+    private enqueueLogTransport;
+    private enqueueErrorTransport;
+    private pumpLogsAfterEnqueue;
+    private pumpErrorsAfterEnqueue;
+    private drainLogStep;
+    private drainErrorStep;
+    private emitFailure;
+    private postJsonWithRetry;
 }

package/dist/types/DuckBug/Log.d.ts

@@ -1,7 +1 @@
-import type { LogLevel } from "../SDK/LogLevel";
-export type Log = {
-    message: string;
-    level: LogLevel;
-    time: number;
-    context: string | undefined;
-};
+export type { DuckBugLogEvent as Log } from "../contract";