@duckbug/js 0.1.2 → 1.0.0

package/dist/cjs/DuckBug/stripIngestSections.cjs

@@ -0,0 +1,43 @@
+"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__, {
+    stripIngestSections: ()=>stripIngestSections
+});
+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;
+}
+exports.stripIngestSections = __webpack_exports__.stripIngestSections;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "stripIngestSections"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/DuckBug/transportTypes.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/SDK/DuckSDK.cjs

@@ -24,37 +24,156 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    DuckSDK: ()=>DuckSDK
+    DuckSDK: ()=>DuckSDK,
+    Duck: ()=>Duck
 });
-const external_index_cjs_namespaceObject = require("./index.cjs");
+const DuckBugHelper_cjs_namespaceObject = require("../DuckBug/DuckBugHelper.cjs");
+const finalizeIngestEvent_cjs_namespaceObject = require("../DuckBug/finalizeIngestEvent.cjs");
+const external_sdkIdentity_cjs_namespaceObject = require("../sdkIdentity.cjs");
+const external_LogLevel_cjs_namespaceObject = require("./LogLevel.cjs");
+const external_LogProvider_cjs_namespaceObject = require("./LogProvider.cjs");
+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;
-        new external_index_cjs_namespaceObject.LogProvider(providers, logProviderConfig);
+        this.beforeSendHook = options?.beforeSend;
+        this.extraSensitiveKeys = options?.extraSensitiveKeys;
+        this.stripSections = options?.stripSections;
+        new external_LogProvider_cjs_namespaceObject.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, external_index_cjs_namespaceObject.logLevel.DEBUG, payload);
+        this.emitLog(external_LogLevel_cjs_namespaceObject.logLevel.DEBUG, tag, payload);
     }
     error(tag, payload) {
-        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.DEBUG, payload);
+        this.emitLog(external_LogLevel_cjs_namespaceObject.logLevel.ERROR, tag, payload);
     }
     debug(tag, payload) {
-        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.DEBUG, payload);
+        this.emitLog(external_LogLevel_cjs_namespaceObject.logLevel.DEBUG, tag, payload);
     }
     warn(tag, payload) {
-        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.WARN, payload);
+        this.emitLog(external_LogLevel_cjs_namespaceObject.logLevel.WARN, tag, payload);
     }
     fatal(tag, payload) {
-        this.sendReportToPlugins(tag, external_index_cjs_namespaceObject.logLevel.FATAL, payload);
+        this.emitLog(external_LogLevel_cjs_namespaceObject.logLevel.FATAL, tag, payload);
+    }
+    quack(tag, error) {
+        const time = Date.now();
+        const built = (0, DuckBugHelper_cjs_namespaceObject.processError)(error, tag, time);
+        const merged = this.mergeScope(built);
+        const finalized = (0, finalizeIngestEvent_cjs_namespaceObject.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: {
+                ...external_sdkIdentity_cjs_namespaceObject.SDK_IDENTITY
+            },
+            ...void 0 !== payload ? {
+                context: payload
+            } : {}
+        });
+        const finalized = (0, finalizeIngestEvent_cjs_namespaceObject.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);
     }
 }
+exports.Duck = __webpack_exports__.Duck;
 exports.DuckSDK = __webpack_exports__.DuckSDK;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Duck",
     "DuckSDK"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/SDK/index.cjs

@@ -24,17 +24,20 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    LogProvider: ()=>external_LogProvider_cjs_namespaceObject.LogProvider,
+    Duck: ()=>external_DuckSDK_cjs_namespaceObject.Duck,
     logLevel: ()=>external_LogLevel_cjs_namespaceObject.logLevel,
-    DuckSDK: ()=>external_DuckSDK_cjs_namespaceObject.DuckSDK
+    DuckSDK: ()=>external_DuckSDK_cjs_namespaceObject.DuckSDK,
+    LogProvider: ()=>external_LogProvider_cjs_namespaceObject.LogProvider
 });
 const external_DuckSDK_cjs_namespaceObject = require("./DuckSDK.cjs");
 const external_LogLevel_cjs_namespaceObject = require("./LogLevel.cjs");
 const external_LogProvider_cjs_namespaceObject = require("./LogProvider.cjs");
+exports.Duck = __webpack_exports__.Duck;
 exports.DuckSDK = __webpack_exports__.DuckSDK;
 exports.LogProvider = __webpack_exports__.LogProvider;
 exports.logLevel = __webpack_exports__.logLevel;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Duck",
     "DuckSDK",
     "LogProvider",
     "logLevel"

package/dist/cjs/contract/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/contract/ingestEvents.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.cjs

@@ -5,6 +5,12 @@ var __webpack_modules__ = {
     },
     "./SDK": function(module) {
         module.exports = require("./SDK/index.cjs");
+    },
+    "./contract": function(module) {
+        module.exports = require("./contract/index.cjs");
+    },
+    "./integrations/node": function(module) {
+        module.exports = require("./integrations/node.cjs");
     }
 };
 var __webpack_module_cache__ = {};
@@ -50,16 +56,28 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _DuckBug__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./DuckBug");
+    var _contract__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./contract");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _contract__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _contract__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _DuckBug__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./DuckBug");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _DuckBug__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _DuckBug__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _integrations_node__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./integrations/node");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _DuckBug__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _DuckBug__WEBPACK_IMPORTED_MODULE_0__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _integrations_node__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _integrations_node__WEBPACK_IMPORTED_MODULE_2__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _SDK__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./SDK");
+    var _SDK__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./SDK");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _SDK__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _SDK__WEBPACK_IMPORTED_MODULE_1__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _SDK__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _SDK__WEBPACK_IMPORTED_MODULE_3__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/cjs/integrations/node.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__, {
+    registerNodeGlobalErrorHandlers: ()=>registerNodeGlobalErrorHandlers
+});
+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);
+    };
+}
+exports.registerNodeGlobalErrorHandlers = __webpack_exports__.registerNodeGlobalErrorHandlers;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "registerNodeGlobalErrorHandlers"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/sdkIdentity.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__, {
+    SDK_IDENTITY: ()=>SDK_IDENTITY,
+    SDK_NAME: ()=>SDK_NAME,
+    SDK_VERSION: ()=>SDK_VERSION
+});
+const SDK_NAME = "@duckbug/js";
+const SDK_VERSION = "0.1.3";
+const SDK_IDENTITY = {
+    name: SDK_NAME,
+    version: SDK_VERSION
+};
+exports.SDK_IDENTITY = __webpack_exports__.SDK_IDENTITY;
+exports.SDK_NAME = __webpack_exports__.SDK_NAME;
+exports.SDK_VERSION = __webpack_exports__.SDK_VERSION;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "SDK_IDENTITY",
+    "SDK_NAME",
+    "SDK_VERSION"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/DuckBug/DuckBugHelper.js

@@ -0,0 +1,99 @@
+import { SDK_IDENTITY } from "../sdkIdentity.js";
+function tryJsonObjectFromMessage(message) {
+    const trimmed = message.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+    try {
+        const v = JSON.parse(message);
+        if (null !== v && "object" == typeof v) return v;
+    } catch  {}
+    return null;
+}
+function parseStacktrace(stack) {
+    let file = "unknown";
+    let line = 0;
+    let stacktrace;
+    if (stack) {
+        const stackLines = stack.split("\n");
+        let firstStackLineWithFile = null;
+        for(let i = 1; i < stackLines.length; i++){
+            const lineStr = stackLines[i];
+            if (-1 !== lineStr.indexOf("at ") && (-1 !== lineStr.indexOf(":") || -1 !== lineStr.indexOf("("))) {
+                firstStackLineWithFile = lineStr;
+                break;
+            }
+        }
+        if (firstStackLineWithFile) {
+            const match = firstStackLineWithFile.match(/\(([^)]+):(\d+):(\d+)\)/) || firstStackLineWithFile.match(/at\s+.*?\(([^)]+):(\d+):(\d+)\)/) || firstStackLineWithFile.match(/([^:()\s]+):(\d+):(\d+)/);
+            if (match?.[1]) {
+                file = match[1].replace(/^file:\/\//, "").replace(/^\/+/, "");
+                line = parseInt(match[2] || "0", 10);
+            }
+        }
+        stacktrace = {
+            raw: stack,
+            frames: stackLines.filter((lineStr)=>lineStr.trim()).map((lineStr, index)=>({
+                    index,
+                    content: lineStr.trim()
+                }))
+        };
+    } else {
+        stacktrace = {
+            raw: "",
+            frames: []
+        };
+        file = "unknown";
+        line = 0;
+    }
+    return {
+        file,
+        line,
+        stacktrace
+    };
+}
+function parseContext(contextStr) {
+    if (!contextStr) return null;
+    try {
+        return JSON.parse(contextStr);
+    } catch  {
+        return {
+            message: contextStr
+        };
+    }
+}
+function parseError(error) {
+    const { file, line, stacktrace } = parseStacktrace(error.stack);
+    const context = parseContext(error.message);
+    return {
+        file,
+        line,
+        stacktrace,
+        context
+    };
+}
+function processError(error, tag, time) {
+    const parsed = parseError(error);
+    const message = "string" == typeof error.message && error.message.length > 0 ? error.message : "Error";
+    const event = {
+        time,
+        message,
+        stacktrace: parsed.stacktrace,
+        stacktraceAsString: error.stack ?? "",
+        file: parsed.file,
+        line: parsed.line,
+        exception: {
+            type: error.name,
+            message: error.message
+        },
+        platform: "node",
+        sdk: {
+            ...SDK_IDENTITY
+        }
+    };
+    if (tag.length > 0) event.dTags = [
+        tag
+    ];
+    const fromJson = tryJsonObjectFromMessage(error.message);
+    if (fromJson) event.extra = fromJson;
+    return event;
+}
+export { parseError, processError };

package/dist/esm/DuckBug/DuckBugProvider.js

@@ -1,48 +1,117 @@
 import { logLevel } from "../SDK/index.js";
+import { processError } from "./DuckBugHelper.js";
 import { DuckBugService } from "./DuckBugService.js";
+import { finalizeIngestEvent } from "./finalizeIngestEvent.js";
 class DuckBugProvider {
     service;
+    ingestConfig;
     constructor(config){
+        this.ingestConfig = config;
         this.service = new 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 = 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 = finalizeIngestEvent(event, {
+            extraSensitiveKeys: this.ingestConfig.extraSensitiveKeys,
+            stripSections: this.ingestConfig.stripSections
+        });
+        this.service.sendError(prepared);
+    }
+    async sendLogAsync(event, _meta) {
+        const prepared = 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 = 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: logLevel.WARN,
             message: this.convertArgsToString(args[0]),
-            context: this.convertArgsToString(args.slice(1))
+            ...this.normalizedContextPayload(args.slice(1))
         });
     }
     error(...args) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level: logLevel.ERROR,
             message: this.convertArgsToString(args[0]),
-            context: this.convertArgsToString(args.slice(1))
+            ...this.normalizedContextPayload(args.slice(1))
         });
     }
     log(...args) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level: logLevel.INFO,
             message: this.convertArgsToString(args[0]),
-            context: this.convertArgsToString(args.slice(1))
+            ...this.normalizedContextPayload(args.slice(1))
         });
     }
     report(tag, level, payload) {
-        this.service.sendLog({
+        this.sendLog({
             time: this.getTimeStamp(),
             level,
             message: tag,
-            context: JSON.stringify(payload)
+            ...void 0 !== payload ? {
+                context: payload
+            } : {}
         });
     }
     quack(tag, error) {
-        this.service.sendError({
-            stack: error.stack,
-            message: tag,
-            context: error.message
-        });
+        const errorRequest = 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(" ");