@kubb/agent 4.29.1 → 4.31.0

package/.output/server/node_modules/@logtail/node/dist/cjs/context.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStackContext = getStackContext;
+const path_1 = require("path");
+const stack_trace_1 = __importDefault(require("stack-trace"));
+const mainFile = mainFileName();
+/**
+ * Determines the file name and the line number from which the log
+ * was initiated (if we're able to tell).
+ *
+ * @returns Context The caller's filename and the line number
+ */
+function getStackContext(logtail, stackContextHint) {
+    const stackFrame = getCallingFrame(logtail, stackContextHint);
+    if (stackFrame === null)
+        return {};
+    return {
+        context: {
+            runtime: {
+                file: relativeToMainModule(stackFrame.getFileName()),
+                type: stackFrame.getTypeName(),
+                method: stackFrame.getMethodName(),
+                function: stackFrame.getFunctionName(),
+                line: stackFrame.getLineNumber(),
+                column: stackFrame.getColumnNumber(),
+            },
+            system: {
+                pid: process.pid,
+                main_file: mainFile,
+            },
+        },
+    };
+}
+function getCallingFrame(logtail, stackContextHint) {
+    for (let fn of [logtail.warn, logtail.error, logtail.info, logtail.debug, logtail.log]) {
+        const stack = stack_trace_1.default.get(fn);
+        if ((stack === null || stack === void 0 ? void 0 : stack.length) > 0)
+            return getRelevantStackFrame(stack, stackContextHint);
+    }
+    return null;
+}
+function getRelevantStackFrame(frames, stackContextHint) {
+    if (stackContextHint) {
+        frames.reverse();
+        let index = frames.findIndex((frame) => {
+            var _a;
+            return (((_a = frame.getFileName()) === null || _a === void 0 ? void 0 : _a.includes(stackContextHint.fileName)) &&
+                (stackContextHint.methodNames.includes(frame.getMethodName()) ||
+                    stackContextHint.methodNames.includes(frame.getFunctionName())));
+        });
+        if (index > 0) {
+            return frames[index - 1];
+        }
+        if (stackContextHint.required) {
+            return null;
+        }
+        return frames[frames.length - 1];
+    }
+    return frames[0];
+}
+function relativeToMainModule(fileName) {
+    if (typeof fileName !== "string") {
+        return null;
+    }
+    else if (fileName.startsWith("file:/")) {
+        const url = new URL(fileName);
+        return url.pathname;
+    }
+    else {
+        const rootPath = (0, path_1.dirname)(mainFileName());
+        return (0, path_1.relative)(rootPath, fileName);
+    }
+}
+function mainFileName() {
+    let argv = process === null || process === void 0 ? void 0 : process.argv;
+    if (argv === undefined)
+        return "";
+    // return first js file argument - arg ending in .js
+    for (const arg of argv) {
+        if (typeof arg !== "string" || arg.startsWith("-")) {
+            // break on first option
+            break;
+        }
+        if (arg.endsWith(".js")) {
+            return arg;
+        }
+    }
+    return "";
+}
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logtail = void 0;
+const node_1 = require("./node");
+Object.defineProperty(exports, "Logtail", { enumerable: true, get: function () { return node_1.Node; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const msgpack_1 = require("@msgpack/msgpack");
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+const core_1 = require("@logtail/core");
+const context_1 = require("./context");
+class Node extends core_1.Base {
+    constructor(sourceToken, options) {
+        options = Object.assign({ timeout: 30000 }, options);
+        super(sourceToken, options);
+        const agent = this.createAgent();
+        // Sync function
+        const sync = async (logs) => {
+            const nodeOptions = this._options;
+            const request = this.getHttpModule().request(nodeOptions.endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/msgpack",
+                    "Content-Encoding": "gzip",
+                    Authorization: `Bearer ${this._sourceToken}`,
+                    "User-Agent": "logtail-js(node)",
+                },
+                agent,
+                timeout: nodeOptions.timeout > 0 ? nodeOptions.timeout : undefined,
+            });
+            const response = await new Promise((resolve, reject) => {
+                // Setup timeout handler if timeout is configured
+                if (nodeOptions.timeout > 0) {
+                    request.on("timeout", () => {
+                        request.destroy();
+                        reject(new Error(`Request timeout after ${nodeOptions.timeout}ms`));
+                    });
+                }
+                request.on("response", resolve);
+                request.on("error", reject);
+                // Compress the logs using gzip
+                node_zlib_1.default.gzip(this.encodeAsMsgpack(logs), (err, compressedData) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    request.write(compressedData);
+                    request.end();
+                });
+            });
+            if (response.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+                return logs;
+            }
+            throw new Error(response.statusMessage);
+        };
+        // Set the throttled sync function
+        this.setSync(sync);
+    }
+    /**
+     * Override `Base` log to enable Node.js streaming
+     *
+     * @param message: string - Log message
+     * @param level (LogLevel) - Level to log at (debug|info|warn|error)
+     * @param context: (Context) - Log context for passing structured data
+     * @param stackContextHint: (StackContextHint|null) - Info about which methods to consider as origin in context.runtime
+     * @returns Promise<ILogtailLog> after syncing
+     */
+    async log(message, level, context = {}, stackContextHint) {
+        // Process/sync the log, per `Base` logic
+        context = Object.assign(Object.assign({}, (0, context_1.getStackContext)(this, stackContextHint)), context);
+        const processedLog = await super.log(message, level, context);
+        // Push the processed log to the stream, for piping
+        if (this._writeStream) {
+            this._writeStream.write(JSON.stringify(processedLog) + "\n");
+        }
+        // Return the transformed log
+        return processedLog;
+    }
+    /**
+     * Pipe JSON stringified `ILogtailLog` to a stream after syncing
+     *
+     * @param stream - Writable|Duplex stream
+     */
+    pipe(stream) {
+        this._writeStream = stream;
+        return stream;
+    }
+    encodeAsMsgpack(logs) {
+        const encoded = (0, msgpack_1.encode)(logs);
+        const buffer = Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+        return buffer;
+    }
+    createAgent() {
+        const nodeOptions = this._options;
+        const family = nodeOptions.useIPv6 ? 6 : 4;
+        return new (this.getHttpModule().Agent)({
+            family,
+        });
+    }
+    getHttpModule() {
+        return this._options.endpoint.startsWith("https") ? node_https_1.default : node_http_1.default;
+    }
+}
+exports.Node = Node;
+//# sourceMappingURL=node.js.map

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

@@ -0,0 +1,53 @@
+{
+  "name": "@logtail/node",
+  "version": "0.5.6",
+  "description": "Better Stack Node.js logger (formerly Logtail)",
+  "keywords": [
+    "Better Stack",
+    "Logtail",
+    "logger",
+    "logging",
+    "Node"
+  ],
+  "author": "Better Stack <hello@betterstack.com>",
+  "homepage": "https://github.com/logtail/logtail-js/tree/master/packages/node#readme",
+  "license": "ISC",
+  "main": "dist/cjs/index.js",
+  "module": "dist/es6/index.js",
+  "types": "dist/es6/index.d.ts",
+  "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": {
+    "@types/fetch-mock": "^7.3.1",
+    "@types/nock": "^11.1.0",
+    "nock": "^14.0.1"
+  },
+  "dependencies": {
+    "@logtail/core": "^0.5.6",
+    "@logtail/types": "^0.5.6",
+    "@msgpack/msgpack": "^2.5.1",
+    "@types/stack-trace": "^0.0.33",
+    "minimatch": "^9.0.5",
+    "stack-trace": "0.0.10"
+  },
+  "gitHead": "6901c2b90af7cf9dda3e7c8be7c145d4d83e72a8"
+}

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