@kubb/agent 4.29.1 → 4.31.1

package/.output/server/node_modules/@logtail/tools/dist/cjs/batch.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateJsonLogSizeBytes = void 0;
+exports.default = makeBatch;
+/*
+ * Default buffer size
+ */
+const DEFAULT_BUFFER_SIZE = 1000;
+/*
+ * Default flush timeout
+ */
+const DEFAULT_FLUSH_TIMEOUT = 1000;
+/*
+ * Default retry count
+ */
+const DEFAULT_RETRY_COUNT = 3;
+/*
+ * Default retry backoff
+ */
+const DEFAULT_RETRY_BACKOFF = 100;
+/*
+ * Default function for computing log size (serialized JSON length + 1 for comma)
+ */
+const calculateJsonLogSizeBytes = (log) => JSON.stringify(log).length + 1;
+exports.calculateJsonLogSizeBytes = calculateJsonLogSizeBytes;
+/**
+ * batch the buffer coming in, process them and then resolve
+ *
+ * @param size - Number
+ * @param flushTimeout - Number
+ * @param retryCount - Number
+ * @param retryBackoff - Number
+ * @param sizeBytes - Size of the batch (in bytes) that triggers flushing. Set to 0 to disable.
+ * @param calculateLogSizeBytes - Function to calculate size of a single ILogtailLog instance (in bytes).
+ */
+function makeBatch(size = DEFAULT_BUFFER_SIZE, flushTimeout = DEFAULT_FLUSH_TIMEOUT, retryCount = DEFAULT_RETRY_COUNT, retryBackoff = DEFAULT_RETRY_BACKOFF, sizeBytes = 0, calculateLogSizeBytes = exports.calculateJsonLogSizeBytes) {
+    let timeout;
+    let cb;
+    let buffer = [];
+    let bufferSizeBytes = 0;
+    let retry = 0;
+    // Wait until the minimum retry backoff time has passed before retrying
+    let minRetryBackoff = 0;
+    /*
+     * Process then flush the list
+     */
+    async function flush() {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = null;
+        const currentBuffer = buffer;
+        const currentBufferSizeKB = bufferSizeBytes;
+        buffer = [];
+        bufferSizeBytes = 0;
+        try {
+            await cb(currentBuffer.map((d) => d.log));
+            currentBuffer.forEach((d) => d.resolve(d.log));
+            retry = 0;
+        }
+        catch (e) {
+            if (retry < retryCount) {
+                retry++;
+                minRetryBackoff = Date.now() + retryBackoff;
+                buffer = buffer.concat(currentBuffer);
+                bufferSizeBytes += currentBufferSizeKB;
+                await setupTimeout();
+                return;
+            }
+            currentBuffer.map((d) => d.reject(e));
+            retry = 0;
+        }
+    }
+    /*
+     * Start timeout to flush
+     */
+    async function setupTimeout() {
+        if (timeout) {
+            return;
+        }
+        return new Promise((resolve) => {
+            timeout = setTimeout(async function () {
+                await flush();
+                resolve();
+            }, flushTimeout);
+        });
+    }
+    /*
+     * Batcher which takes a process function
+     * @param fn - Any function to process list
+     */
+    return {
+        initPusher: function (fn) {
+            cb = fn;
+            /*
+             * Pushes each log into list
+             * @param log: ILogtailLog - Any object to push into list
+             */
+            return async function (log) {
+                return new Promise(async (resolve, reject) => {
+                    buffer.push({ log, resolve, reject });
+                    // We can skip log size calculation if there is no max size set
+                    if (sizeBytes > 0) {
+                        bufferSizeBytes += calculateLogSizeBytes(log);
+                    }
+                    // If the buffer is full enough, flush it
+                    // Unless we're still waiting for the minimum retry backoff time
+                    const isBufferFullEnough = buffer.length >= size || (sizeBytes > 0 && bufferSizeBytes >= sizeBytes);
+                    if (isBufferFullEnough && Date.now() > minRetryBackoff) {
+                        await flush();
+                    }
+                    else {
+                        await setupTimeout();
+                    }
+                    return resolve;
+                });
+            };
+        },
+        flush,
+    };
+}
+//# sourceMappingURL=batch.js.map

package/.output/server/node_modules/@logtail/tools/dist/cjs/burstProtection.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = makeBurstProtection;
+const RESOLUTION = 64;
+/**
+ * Create a burst protection which allows running function only a number of times in a configurable window
+ * @param milliseconds - length of the checked window in milliseconds
+ * @param max - maximum number of functions to run in that window
+ * @param functionName - function name for error message
+ */
+function makeBurstProtection(milliseconds, max, functionName = "The function") {
+    if (milliseconds <= 0 || max <= 0) {
+        return (fn) => fn;
+    }
+    let callCounts = [0];
+    let lastErrorOutput = 0;
+    let lastIntervalTime = Date.now();
+    function updateCallCounts() {
+        const now = Date.now();
+        const intervalLength = milliseconds / RESOLUTION;
+        if (now < lastIntervalTime + intervalLength) {
+            return;
+        }
+        // Prepend callCounts with correct number of zeroes and keep its length to RESOLUTION at max
+        const intervalCountSinceLast = Math.floor((now - lastIntervalTime) / intervalLength);
+        callCounts = Array(Math.min(intervalCountSinceLast, RESOLUTION)).fill(0).concat(callCounts).slice(0, RESOLUTION);
+        lastIntervalTime += intervalCountSinceLast * intervalLength;
+    }
+    function getTotalCallCount() {
+        return callCounts.reduce((total, item) => total + item);
+    }
+    function incrementCallCount() {
+        callCounts[0]++;
+    }
+    return (fn) => {
+        return async (...args) => {
+            updateCallCounts();
+            if (getTotalCallCount() < max) {
+                incrementCallCount();
+                return await fn(...args);
+            }
+            const now = Date.now();
+            if (lastErrorOutput < now - milliseconds) {
+                lastErrorOutput = now;
+                console.error(`${functionName} was called more than ${max} times during last ${milliseconds}ms. Ignoring.`);
+            }
+        };
+    };
+}
+//# sourceMappingURL=burstProtection.js.map

package/.output/server/node_modules/@logtail/tools/dist/cjs/encode.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Encode = base64Encode;
+/**
+ * Converts a plain-text string to a base64 string
+ *
+ * @param str - Plain text string -> base64
+ */
+function base64Encode(str) {
+    return Buffer.from(str).toString("base64");
+}
+//# sourceMappingURL=encode.js.map

package/.output/server/node_modules/@logtail/tools/dist/cjs/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateJsonLogSizeBytes = exports.makeThrottle = exports.makeBurstProtection = exports.makeBatch = exports.base64Encode = exports.Queue = void 0;
+const queue_1 = __importDefault(require("./queue"));
+exports.Queue = queue_1.default;
+const encode_1 = require("./encode");
+Object.defineProperty(exports, "base64Encode", { enumerable: true, get: function () { return encode_1.base64Encode; } });
+const batch_1 = __importStar(require("./batch"));
+exports.makeBatch = batch_1.default;
+Object.defineProperty(exports, "calculateJsonLogSizeBytes", { enumerable: true, get: function () { return batch_1.calculateJsonLogSizeBytes; } });
+const burstProtection_1 = __importDefault(require("./burstProtection"));
+exports.makeBurstProtection = burstProtection_1.default;
+const throttle_1 = __importDefault(require("./throttle"));
+exports.makeThrottle = throttle_1.default;
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@logtail/tools/dist/cjs/queue.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Queue, for FIFO access to arbitrary objects. Intended to be a faster
+ * replacement for a Javascript array.
+ */
+class Queue {
+    constructor() {
+        /**
+         * First node in the tree
+         */
+        /**
+         * Number of items in the queue
+         */
+        this.length = 0;
+    }
+    /**
+     * Pushes a value into the queue.
+     * @param value - Any object to push into the queue
+     */
+    push(value) {
+        const node = { value };
+        this.last = this.last ? (this.last.next = node) : (this.first = node);
+        this.length++;
+    }
+    /**
+     * Remove a value from the start of the queue (FIFO) and return it
+     */
+    shift() {
+        if (this.first) {
+            const { value } = this.first;
+            this.first = this.first.next;
+            if (!--this.length) {
+                this.last = undefined;
+            }
+            return value;
+        }
+    }
+}
+exports.default = Queue;
+//# sourceMappingURL=queue.js.map

package/.output/server/node_modules/@logtail/tools/dist/cjs/throttle.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = makeThrottle;
+const queue_1 = __importDefault(require("./queue"));
+/**
+ * Create a throttle which runs up to `max` async functions at once
+ * @param max - maximum number of async functions to run
+ * @param queueMax - maximum number of functions to queue (-1 = unlimited, default)
+ */
+function makeThrottle(max, queueMax = -1) {
+    // Current iteration cycle
+    let current = 0;
+    // Create a FIFO queue
+    const queue = new queue_1.default();
+    /**
+     * Throttle function that throttles the passed func according to `max`
+     * @param fn - async function to resolve
+     */
+    function throttle(fn) {
+        return async (...args) => {
+            return new Promise((resolve, reject) => {
+                /**
+                 * Handler for resolving the Promise chain
+                 */
+                async function handler() {
+                    // Only resolve if the `max` hasn't been exhausted
+                    if (current < max) {
+                        // Increment the available slot size
+                        current++;
+                        try {
+                            // Await the passed function here first, to determine if any
+                            // errors are thrown, so they can be handled by our outside `reject`
+                            resolve(await fn(...args));
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                        // Since this has now resolved, make the slot available again
+                        current--;
+                        // If there are items waiting in the queue, resolve the next
+                        // Promise
+                        if (queue.length > 0) {
+                            queue.shift()();
+                        }
+                    }
+                    else if (queueMax < 0 || queue.length < queueMax) {
+                        // The `max` has been exceeded and if queue limit hasn't been hit - push onto the queue to wait
+                        queue.push(handler);
+                    }
+                    else {
+                        // Reject this call due to queue limit
+                        reject(new Error("Queue max limit exceeded"));
+                        return;
+                    }
+                }
+                // Return the async handler
+                return handler();
+            });
+        };
+    }
+    // Return the throttle function
+    return throttle;
+}
+//# sourceMappingURL=throttle.js.map

package/.output/server/node_modules/@logtail/tools/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@logtail/tools",
+  "version": "0.5.6",
+  "description": "Better Stack JavaScript logging tools (formerly Logtail)",
+  "main": "dist/cjs/index.js",
+  "module": "dist/es6/index.js",
+  "types": "dist/es6/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "src",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:cjs": "tsc",
+    "build:es6": "tsc -p tsconfig.es6.json",
+    "build": "run-p build:*",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
+  },
+  "author": "Better Stack <hello@betterstack.com>",
+  "repository": "https://github.com/logtail/logtail-js/tree/master/packages/tools",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/logtail/logtail-js/issues"
+  },
+  "homepage": "https://github.com/logtail/logtail-js/tree/master/packages/tools#readme",
+  "devDependencies": {
+    "@types/nock": "^11.1.0",
+    "@types/source-map": "^0.5.7",
+    "nock": "^14.0.1"
+  },
+  "dependencies": {
+    "@logtail/types": "^0.5.6"
+  },
+  "gitHead": "6901c2b90af7cf9dda3e7c8be7c145d4d83e72a8"
+}

package/.output/server/node_modules/@logtail/types/dist/cjs/types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Logtail library options
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    // core log levels - available as functions
+    LogLevel["Error"] = "error";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Info"] = "info";
+    LogLevel["Debug"] = "debug";
+    // extra log levels - recognized when passed from logging frameworks
+    LogLevel["Fatal"] = "fatal";
+    LogLevel["Http"] = "http";
+    LogLevel["Verbose"] = "verbose";
+    LogLevel["Silly"] = "silly";
+    LogLevel["Trace"] = "trace";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+//# sourceMappingURL=types.js.map

package/.output/server/node_modules/@logtail/types/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@logtail/types",
+  "version": "0.5.6",
+  "description": "Better Stack Typescript types (formerly Logtail)",
+  "keywords": [
+    "Better Stack",
+    "Logtail",
+    "logging",
+    "logger",
+    "typescript",
+    "types"
+  ],
+  "author": "Better Stack <hello@betterstack.com>",
+  "homepage": "https://github.com/logtail/logtail-js/tree/master/packages/types#readme",
+  "license": "ISC",
+  "main": "dist/cjs/types.js",
+  "module": "dist/es6/types.js",
+  "types": "dist/es6/types.d.ts",
+  "sideEffects": false,
+  "files": [
+    "src",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/logtail/logtail-js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:cjs": "tsc",
+    "build:es6": "tsc -p tsconfig.es6.json",
+    "build": "run-p build:*",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "bugs": {
+    "url": "https://github.com/logtail/logtail-js/issues"
+  },
+  "devDependencies": {
+    "npm-run-all": "^4.1.5"
+  },
+  "gitHead": "6901c2b90af7cf9dda3e7c8be7c145d4d83e72a8"
+}

package/.output/server/node_modules/@msgpack/msgpack/dist/CachedKeyDecoder.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedKeyDecoder = void 0;
+const utf8_1 = require("./utils/utf8");
+const DEFAULT_MAX_KEY_LENGTH = 16;
+const DEFAULT_MAX_LENGTH_PER_KEY = 16;
+class CachedKeyDecoder {
+    constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+        this.maxKeyLength = maxKeyLength;
+        this.maxLengthPerKey = maxLengthPerKey;
+        this.hit = 0;
+        this.miss = 0;
+        // avoid `new Array(N)`, which makes a sparse array,
+        // because a sparse array is typically slower than a non-sparse array.
+        this.caches = [];
+        for (let i = 0; i < this.maxKeyLength; i++) {
+            this.caches.push([]);
+        }
+    }
+    canBeCached(byteLength) {
+        return byteLength > 0 && byteLength <= this.maxKeyLength;
+    }
+    find(bytes, inputOffset, byteLength) {
+        const records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (const record of records) {
+            const recordBytes = record.bytes;
+            for (let j = 0; j < byteLength; j++) {
+                if (recordBytes[j] !== bytes[inputOffset + j]) {
+                    continue FIND_CHUNK;
+                }
+            }
+            return record.str;
+        }
+        return null;
+    }
+    store(bytes, value) {
+        const records = this.caches[bytes.length - 1];
+        const record = { bytes, str: value };
+        if (records.length >= this.maxLengthPerKey) {
+            // `records` are full!
+            // Set `record` to an arbitrary position.
+            records[(Math.random() * records.length) | 0] = record;
+        }
+        else {
+            records.push(record);
+        }
+    }
+    decode(bytes, inputOffset, byteLength) {
+        const cachedValue = this.find(bytes, inputOffset, byteLength);
+        if (cachedValue != null) {
+            this.hit++;
+            return cachedValue;
+        }
+        this.miss++;
+        const str = (0, utf8_1.utf8DecodeJs)(bytes, inputOffset, byteLength);
+        // Ensure to copy a slice of bytes because the byte may be NodeJS Buffer and Buffer#slice() returns a reference to its internal ArrayBuffer.
+        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        this.store(slicedCopyOfBytes, str);
+        return str;
+    }
+}
+exports.CachedKeyDecoder = CachedKeyDecoder;
+//# sourceMappingURL=CachedKeyDecoder.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/DecodeError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecodeError = void 0;
+class DecodeError extends Error {
+    constructor(message) {
+        super(message);
+        // fix the prototype chain in a cross-platform way
+        const proto = Object.create(DecodeError.prototype);
+        Object.setPrototypeOf(this, proto);
+        Object.defineProperty(this, "name", {
+            configurable: true,
+            enumerable: false,
+            value: DecodeError.name,
+        });
+    }
+}
+exports.DecodeError = DecodeError;
+//# sourceMappingURL=DecodeError.js.map