@duckbug/js 0.1.3 → 1.0.0

package/dist/cjs/DuckBug/DuckBugProvider.cjs

@@ -27,50 +27,119 @@ __webpack_require__.d(__webpack_exports__, {
     DuckBugProvider: ()=>DuckBugProvider
 });
 const index_cjs_namespaceObject = require("../SDK/index.cjs");
+const external_DuckBugHelper_cjs_namespaceObject = require("./DuckBugHelper.cjs");
 const external_DuckBugService_cjs_namespaceObject = require("./DuckBugService.cjs");
+const external_finalizeIngestEvent_cjs_namespaceObject = require("./finalizeIngestEvent.cjs");
 class DuckBugProvider {
     service;
+    ingestConfig;
     constructor(config){
+        this.ingestConfig = config;
         this.service = new external_DuckBugService_cjs_namespaceObject.DuckBugService(config);
     }
+    static fromDSN(dsn) {
+        return new DuckBugProvider({
+            dsn
+        });
+    }
+    flush() {
+        return this.service.flush();
+    }
+    sendLog(event, meta) {
+        if (meta?.skipPrivacyPipeline) return void this.service.sendLog(event);
+        if (this.ingestConfig.beforeSend) return void this.sendLogAsync(event, meta);
+        const prepared = (0, external_finalizeIngestEvent_cjs_namespaceObject.finalizeIngestEvent)(event, {
+            extraSensitiveKeys: this.ingestConfig.extraSensitiveKeys,
+            stripSections: this.ingestConfig.stripSections
+        });
+        this.service.sendLog(prepared);
+    }
+    sendError(event, meta) {
+        if (meta?.skipPrivacyPipeline) return void this.service.sendError(event);
+        if (this.ingestConfig.beforeSend) return void this.sendErrorAsync(event, meta);
+        const prepared = (0, external_finalizeIngestEvent_cjs_namespaceObject.finalizeIngestEvent)(event, {
+            extraSensitiveKeys: this.ingestConfig.extraSensitiveKeys,
+            stripSections: this.ingestConfig.stripSections
+        });
+        this.service.sendError(prepared);
+    }
+    async sendLogAsync(event, _meta) {
+        const prepared = (0, external_finalizeIngestEvent_cjs_namespaceObject.finalizeIngestEvent)(event, {
+            extraSensitiveKeys: this.ingestConfig.extraSensitiveKeys,
+            stripSections: this.ingestConfig.stripSections
+        });
+        const r = await this.ingestConfig.beforeSend?.({
+            kind: "log",
+            event: prepared
+        });
+        if (null === r) return;
+        const toSend = r ?? prepared;
+        this.service.sendLog(toSend);
+    }
+    async sendErrorAsync(event, _meta) {
+        const prepared = (0, external_finalizeIngestEvent_cjs_namespaceObject.finalizeIngestEvent)(event, {
+            extraSensitiveKeys: this.ingestConfig.extraSensitiveKeys,
+            stripSections: this.ingestConfig.stripSections
+        });
+        const r = await this.ingestConfig.beforeSend?.({
+            kind: "error",
+            event: prepared
+        });
+        if (null === r) return;
+        const toSend = r ?? prepared;
+        this.service.sendError(toSend);
+    }
     warn(...args) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level: index_cjs_namespaceObject.logLevel.WARN,
             message: this.convertArgsToString(args[0]),
-            context: args.slice(1)
+            ...this.normalizedContextPayload(args.slice(1))
         });
     }
     error(...args) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level: index_cjs_namespaceObject.logLevel.ERROR,
             message: this.convertArgsToString(args[0]),
-            context: args.slice(1)
+            ...this.normalizedContextPayload(args.slice(1))
         });
     }
     log(...args) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level: index_cjs_namespaceObject.logLevel.INFO,
             message: this.convertArgsToString(args[0]),
-            context: args.slice(1)
+            ...this.normalizedContextPayload(args.slice(1))
         });
     }
     report(tag, level, payload) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level,
             message: tag,
-            context: payload
+            ...void 0 !== payload ? {
+                context: payload
+            } : {}
         });
     }
     quack(tag, error) {
-        this.service.sendError({
-            stack: error.stack,
-            message: tag,
-            context: error.message
-        });
+        const errorRequest = (0, external_DuckBugHelper_cjs_namespaceObject.processError)(error, tag, this.getTimeStamp());
+        this.sendError(errorRequest);
+    }
+    normalizedContextPayload(rest) {
+        if (0 === rest.length) return {};
+        if (1 === rest.length) {
+            const v = rest[0];
+            return {
+                context: v
+            };
+        }
+        return {
+            context: {
+                args: rest
+            }
+        };
     }
     convertArgsToString(...args) {
         return args.map((arg)=>"object" == typeof arg ? JSON.stringify(arg) : String(arg)).join(" ");

package/dist/cjs/DuckBug/DuckBugService.cjs

@@ -26,27 +26,168 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DuckBugService: ()=>DuckBugService
 });
+const external_parseDuckBugDsn_cjs_namespaceObject = require("./parseDuckBugDsn.cjs");
+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 = (0, external_parseDuckBugDsn_cjs_namespaceObject.parseDuckBugIngestDsn)(config.dsn);
+        this.logsUrl = (0, external_parseDuckBugDsn_cjs_namespaceObject.ingestLogsUrl)(parsed);
+        this.errorsUrl = (0, external_parseDuckBugDsn_cjs_namespaceObject.ingestErrorsUrl)(parsed);
+        this.logsBatchUrl = (0, external_parseDuckBugDsn_cjs_namespaceObject.ingestLogsBatchUrl)(parsed);
+        this.errorsBatchUrl = (0, external_parseDuckBugDsn_cjs_namespaceObject.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)
-        });
-    }
-    sendError(errorInfo) {
-        fetch(`${this.config.dsn}/errors`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(errorInfo)
+        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();
+        });
+    }
+    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/cjs/DuckBug/Pond.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Pond: ()=>Pond
+});
+const Pond = {
+    ripple (extraSensitiveKeys = []) {
+        return {
+            extraSensitiveKeys: [
+                ...extraSensitiveKeys
+            ]
+        };
+    }
+};
+exports.Pond = __webpack_exports__.Pond;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Pond"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/ensureEventId.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ensureEventId: ()=>ensureEventId
+});
+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()
+    };
+}
+exports.ensureEventId = __webpack_exports__.ensureEventId;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ensureEventId"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/finalizeIngestEvent.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    finalizeIngestEvent: ()=>finalizeIngestEvent
+});
+const external_sdkIdentity_cjs_namespaceObject = require("../sdkIdentity.cjs");
+const external_ensureEventId_cjs_namespaceObject = require("./ensureEventId.cjs");
+const external_sanitizeIngestPayload_cjs_namespaceObject = require("./sanitizeIngestPayload.cjs");
+const external_stripIngestSections_cjs_namespaceObject = require("./stripIngestSections.cjs");
+function withDefaultSdk(event) {
+    if (void 0 !== event.sdk) return event;
+    return {
+        ...event,
+        sdk: {
+            ...external_sdkIdentity_cjs_namespaceObject.SDK_IDENTITY
+        }
+    };
+}
+function finalizeIngestEvent(event, options = {}) {
+    const withSdk = withDefaultSdk(event);
+    const stripped = (0, external_stripIngestSections_cjs_namespaceObject.stripIngestSections)(withSdk, options.stripSections);
+    const sanitized = (0, external_sanitizeIngestPayload_cjs_namespaceObject.sanitizeIngestPayload)(stripped, options.extraSensitiveKeys);
+    return (0, external_ensureEventId_cjs_namespaceObject.ensureEventId)(sanitized);
+}
+exports.finalizeIngestEvent = __webpack_exports__.finalizeIngestEvent;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "finalizeIngestEvent"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/index.cjs

@@ -24,12 +24,28 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    DuckBugProvider: ()=>external_DuckBugProvider_cjs_namespaceObject.DuckBugProvider
+    Pond: ()=>external_Pond_cjs_namespaceObject.Pond,
+    finalizeIngestEvent: ()=>external_finalizeIngestEvent_cjs_namespaceObject.finalizeIngestEvent,
+    DuckBugProvider: ()=>external_DuckBugProvider_cjs_namespaceObject.DuckBugProvider,
+    ensureEventId: ()=>external_ensureEventId_cjs_namespaceObject.ensureEventId,
+    stripIngestSections: ()=>external_stripIngestSections_cjs_namespaceObject.stripIngestSections
 });
 const external_DuckBugProvider_cjs_namespaceObject = require("./DuckBugProvider.cjs");
+const external_ensureEventId_cjs_namespaceObject = require("./ensureEventId.cjs");
+const external_finalizeIngestEvent_cjs_namespaceObject = require("./finalizeIngestEvent.cjs");
+const external_Pond_cjs_namespaceObject = require("./Pond.cjs");
+const external_stripIngestSections_cjs_namespaceObject = require("./stripIngestSections.cjs");
 exports.DuckBugProvider = __webpack_exports__.DuckBugProvider;
+exports.Pond = __webpack_exports__.Pond;
+exports.ensureEventId = __webpack_exports__.ensureEventId;
+exports.finalizeIngestEvent = __webpack_exports__.finalizeIngestEvent;
+exports.stripIngestSections = __webpack_exports__.stripIngestSections;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "DuckBugProvider"
+    "DuckBugProvider",
+    "Pond",
+    "ensureEventId",
+    "finalizeIngestEvent",
+    "stripIngestSections"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/DuckBug/parseDuckBugDsn.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ingestErrorsBatchUrl: ()=>ingestErrorsBatchUrl,
+    ingestErrorsUrl: ()=>ingestErrorsUrl,
+    ingestLogsBatchUrl: ()=>ingestLogsBatchUrl,
+    ingestLogsUrl: ()=>ingestLogsUrl,
+    parseDuckBugIngestDsn: ()=>parseDuckBugIngestDsn
+});
+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`;
+}
+exports.ingestErrorsBatchUrl = __webpack_exports__.ingestErrorsBatchUrl;
+exports.ingestErrorsUrl = __webpack_exports__.ingestErrorsUrl;
+exports.ingestLogsBatchUrl = __webpack_exports__.ingestLogsBatchUrl;
+exports.ingestLogsUrl = __webpack_exports__.ingestLogsUrl;
+exports.parseDuckBugIngestDsn = __webpack_exports__.parseDuckBugIngestDsn;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ingestErrorsBatchUrl",
+    "ingestErrorsUrl",
+    "ingestLogsBatchUrl",
+    "ingestLogsUrl",
+    "parseDuckBugIngestDsn"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/sanitizeIngestPayload.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    sanitizeIngestPayload: ()=>sanitizeIngestPayload
+});
+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);
+}
+exports.sanitizeIngestPayload = __webpack_exports__.sanitizeIngestPayload;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "sanitizeIngestPayload"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});