@vectorx/functions-framework 0.0.0-beta-20251112071234

package/lib/sse.js

@@ -0,0 +1,258 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.ServerSentEvent = void 0;
+const events_1 = require("events");
+const stream_1 = require("stream");
+const util = __importStar(require("util"));
+const langfuse_1 = __importDefault(require("./telemetry/langfuse"));
+const helper_1 = require("./utils/helper");
+const kDefaultEncoder = new util.TextEncoder();
+class ServerSentEvent extends events_1.EventEmitter {
+    constructor(ctx) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super();
+        this.closed = false;
+        this.encoder = kDefaultEncoder;
+        this.ctx = ctx;
+        this.stream = new stream_1.PassThrough({
+            objectMode: false,
+        });
+        this.stream.pipe(ctx.res);
+        ctx.respond = false;
+        ctx.req.once("close", () => {
+            this.emit("close");
+            this.closed = true;
+        });
+        if (ctx.req.socket) {
+            ctx.req.socket.setTimeout(0);
+            ctx.req.socket.setNoDelay(true);
+            ctx.req.socket.setKeepAlive(true, 0);
+        }
+        const headers = {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        };
+        if (ctx.state && ctx.state.eventID) {
+            headers["x-open-agent-trace-id"] = ctx.state.eventID;
+        }
+        ctx.set(headers);
+        ctx.status = 200;
+        ctx.flushHeaders();
+        for (const key of ["ctx", "stream", "encoder"]) {
+            Object.defineProperty(this, key, {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+            });
+        }
+        try {
+            const enabled = ((_c = (_b = (_a = ctx.state) === null || _a === void 0 ? void 0 : _a.frameworkOptions) === null || _b === void 0 ? void 0 : _b.redLangfuseConfig) === null || _c === void 0 ? void 0 : _c.enable) === true;
+            if (!enabled)
+                return;
+            const stage = process.env.OPEN_PLATFORM_STAGE || "development";
+            const openId = ctx.headers["open-id"] || undefined;
+            const eventID = (_d = ctx.state) === null || _d === void 0 ? void 0 : _d.eventID;
+            const agentInfo = ((_e = ctx.state) === null || _e === void 0 ? void 0 : _e.agentInfo) || {};
+            const name = [(agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.agentName) || (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.name), agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.version].filter(Boolean).join("@");
+            const metadata = {
+                http: { method: ctx.method, path: ctx.path },
+                eventID,
+                agent: {
+                    id: agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.agentId,
+                    name: (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.agentName) || (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.name),
+                    version: agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.version,
+                },
+            };
+            const trace = (_f = langfuse_1.default === null || langfuse_1.default === void 0 ? void 0 : langfuse_1.default.trace) === null || _f === void 0 ? void 0 : _f.call(langfuse_1.default, {
+                name: name || "chat-app-session",
+                userId: openId,
+                tags: [stage],
+                metadata,
+            });
+            if (trace) {
+                ctx.state.langfuseTrace = trace;
+                (_g = trace.event) === null || _g === void 0 ? void 0 : _g.call(trace, { name: "sse:start", input: (_j = (_h = ctx.state) === null || _h === void 0 ? void 0 : _h.event) !== null && _j !== void 0 ? _j : null, metadata: { path: ctx.path } });
+            }
+        }
+        catch (_k) { }
+    }
+    setEncoder(encoder) {
+        this.encoder = encoder;
+    }
+    emitMessage(event, data) {
+        if (this.closed)
+            return false;
+        const message = {
+            event,
+            data,
+        };
+        return this.send(message);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    send(event) {
+        var _a, _b, _c;
+        const encoder = this.encoder;
+        const stream = this.stream;
+        if (this.closed) {
+            return false;
+        }
+        const events = Array.isArray(event) ? event : [event];
+        const bufs = [];
+        for (const event of events) {
+            if (Buffer.isBuffer(event)) {
+                bufs.push(event);
+            }
+            else if (typeof event === "string") {
+                bufs.push(Buffer.from(encoder.encode(event)));
+            }
+            else if ((0, helper_1.isPlainObject)(event)) {
+                const msgs = eventToMsgs(event);
+                for (const msg of msgs) {
+                    if (Buffer.isBuffer(msg)) {
+                        bufs.push(msg);
+                    }
+                    else {
+                        bufs.push(Buffer.from(encoder.encode(msg)));
+                    }
+                }
+            }
+        }
+        const buf = Buffer.concat(bufs);
+        if (Buffer.byteLength(buf) > 0) {
+            const ok = stream.write(Buffer.concat(bufs));
+            try {
+                const lfTrace = (_a = this.ctx.state) === null || _a === void 0 ? void 0 : _a.langfuseTrace;
+                if (lfTrace) {
+                    let output = null;
+                    try {
+                        if (!Array.isArray(event)) {
+                            if (typeof event === "string")
+                                output = event;
+                            else if (Buffer.isBuffer(event))
+                                output = event.toString("utf-8");
+                            else if ((0, helper_1.isPlainObject)(event))
+                                output = (_b = event.data) !== null && _b !== void 0 ? _b : null;
+                        }
+                        else {
+                            const last = event[event.length - 1];
+                            if (typeof last === "string")
+                                output = last;
+                            else if (Buffer.isBuffer(last))
+                                output = last.toString("utf-8");
+                            else if ((0, helper_1.isPlainObject)(last))
+                                output = (_c = last.data) !== null && _c !== void 0 ? _c : null;
+                        }
+                    }
+                    catch (_d) { }
+                    lfTrace.event({
+                        name: "sse:send",
+                        input: null,
+                        output,
+                        metadata: { size: Buffer.byteLength(buf) },
+                    });
+                }
+            }
+            catch (_e) { }
+            return ok;
+        }
+        return false;
+    }
+    end(msg) {
+        var _a, _b, _c, _d, _e, _f;
+        if (msg) {
+            this.send(msg);
+        }
+        this.stream.end();
+        this.ctx.res.end();
+        this.closed = true;
+        try {
+            const lfTrace = (_a = this.ctx.state) === null || _a === void 0 ? void 0 : _a.langfuseTrace;
+            const enabled = ((_d = (_c = (_b = this.ctx.state) === null || _b === void 0 ? void 0 : _b.frameworkOptions) === null || _c === void 0 ? void 0 : _c.redLangfuseConfig) === null || _d === void 0 ? void 0 : _d.enable) === true;
+            if (lfTrace) {
+                lfTrace.event({ name: "sse:end", input: null, output: null });
+            }
+            if (enabled && (langfuse_1.default === null || langfuse_1.default === void 0 ? void 0 : langfuse_1.default.shutdownAsync)) {
+                (_f = (_e = langfuse_1.default).shutdownAsync) === null || _f === void 0 ? void 0 : _f.call(_e);
+            }
+        }
+        catch (_g) { }
+    }
+    get isClosed() {
+        return this.closed;
+    }
+}
+exports.ServerSentEvent = ServerSentEvent;
+function eventToMsgs(event) {
+    const msgs = [];
+    if ("comment" in event) {
+        msgs.push(`: ${event.comment}\n`);
+    }
+    if ("event" in event) {
+        msgs.push(`event: ${event.event}\n`);
+    }
+    if ("id" in event) {
+        msgs.push(`id: ${event.id}\n`);
+    }
+    if ("retry" in event) {
+        msgs.push(`retry: ${event.retry}\n`);
+    }
+    if ("data" in event) {
+        msgs.push(toDataEventString(event.data));
+    }
+    if (msgs.length > 0) {
+        msgs.push("\n");
+    }
+    return msgs;
+}
+function toDataEventString(data) {
+    if (Buffer.isBuffer(data)) {
+        return Buffer.concat([Buffer.from("data: "), data, Buffer.from("\n")]);
+    }
+    if ((0, helper_1.isPlainObject)(data)) {
+        return toDataEventString(JSON.stringify(data));
+    }
+    const dataStr = typeof data !== "string" ? `${data}` : data;
+    return dataStr
+        .split(/[\r\n]+/)
+        .map((line) => `data: ${line}\n`)
+        .join("");
+}

package/lib/telemetry/langfuse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.langfuse = void 0;
+const langfuse_1 = require("langfuse");
+const secretKey = process.env.LANGFUSE_SECRET_KEY;
+const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
+const baseUrl = process.env.LANGFUSE_BASEURL;
+exports.langfuse = new langfuse_1.Langfuse({
+    secretKey: "sk-lf-f389bb1e-24db-4b42-b506-8d6118f45044",
+    publicKey: "pk-lf-ee301553-7a64-4f0f-bf6b-a2ac1e5ca2df",
+    baseUrl: "https://xray-langfuse.devops.xiaohongshu.com",
+});
+exports.default = exports.langfuse;

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/unified-responder.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendResponse = sendResponse;
+const error_1 = require("./error");
+const logger_1 = require("./logger");
+function sendResponse(ctx, data, error, errStatusCode = 500, withStack = true) {
+    if (error) {
+        if (!ctx.response) {
+            return;
+        }
+        const errorStack = (0, error_1.decorateErrorStack)(error.cause);
+        logger_1.functionsLogger.log(logger_1.LogType.ACCESS, logger_1.LogLevel.ERROR, error.message, {
+            code: error.code,
+            stack: errorStack,
+            statusCode: errStatusCode,
+        });
+        console.error(`[ERROR] ${error.message}\n${errorStack}`);
+        ctx.status = errStatusCode;
+        if (withStack) {
+            data = {
+                code: error.code,
+                message: error.message,
+                stack: errorStack,
+                requestId: ctx.state.eventID,
+            };
+        }
+        else {
+            data = {
+                code: error.code,
+                message: error.message,
+                requestId: ctx.state.eventID,
+            };
+        }
+    }
+    if (isIntegrationResponse(data)) {
+        return sendIntegrationResponse(ctx, data);
+    }
+    if (typeof data === "undefined" || data === null) {
+        ctx.status = 204;
+    }
+    else {
+        ctx.body = data;
+    }
+    const eResult = data;
+    if (eResult && eResult.code) {
+        ctx.state.errorResult = {
+            code: eResult.code,
+            message: eResult.message,
+        };
+    }
+    return;
+}
+function isIntegrationResponse(result) {
+    if (typeof result !== "object" || !result) {
+        return false;
+    }
+    const { statusCode, headers } = result;
+    return typeof statusCode === "number" && typeof headers === "object";
+}
+function sendIntegrationResponse(ctx, result) {
+    ctx.set(result.headers);
+    ctx.body = result.body;
+    ctx.status = result.statusCode;
+}

package/lib/user-logger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeUserCodeLogs = takeUserCodeLogs;
+exports.pushUserCodeLogs = pushUserCodeLogs;
+exports.addUserCodeLog = addUserCodeLog;
+exports.getUserCodeLogs = getUserCodeLogs;
+const async_context_1 = require("./async-context");
+const logger_1 = require("./logger");
+const USER_CODE_LOGS_MAX_COUNT = 100;
+const USER_CODE_LOGS_FLUSH_TIMER_TIMEOUT = 1000;
+function lazyInitUserCodeLogs() {
+    const currentContext = (0, async_context_1.getCurrentAsyncContext)();
+    if (currentContext && currentContext.userCodeLogs === undefined) {
+        currentContext.userCodeLogs = [];
+    }
+}
+function takeUserCodeLogs() {
+    lazyInitUserCodeLogs();
+    const context = (0, async_context_1.getCurrentAsyncContext)();
+    if (context !== undefined) {
+        const logs = context.userCodeLogs || [];
+        context.userCodeLogs = [];
+        return logs;
+    }
+    return [];
+}
+function pushUserCodeLogs(log) {
+    lazyInitUserCodeLogs();
+    const context = (0, async_context_1.getCurrentAsyncContext)();
+    if (context === null || context === void 0 ? void 0 : context.userCodeLogs) {
+        context.userCodeLogs.push(log);
+    }
+}
+function addUserCodeLog(log) {
+    var _a;
+    lazyInitUserCodeLogs();
+    const userCodeLogs = ((_a = (0, async_context_1.getCurrentAsyncContext)()) === null || _a === void 0 ? void 0 : _a.userCodeLogs) || [];
+    if (userCodeLogs.length >= USER_CODE_LOGS_MAX_COUNT) {
+        logger_1.functionsLogger.logUserCodelog();
+    }
+    const currentContext = (0, async_context_1.getCurrentAsyncContext)();
+    if (currentContext && currentContext.done && !currentContext.userCodeLogsFlushTimer) {
+        currentContext.userCodeLogsFlushTimer = setTimeout(() => {
+            logger_1.functionsLogger.logUserCodelog();
+            currentContext.userCodeLogsFlushTimer = undefined;
+        }, USER_CODE_LOGS_FLUSH_TIMER_TIMEOUT);
+    }
+    pushUserCodeLogs(log);
+}
+function getUserCodeLogs() {
+    lazyInitUserCodeLogs();
+    const context = (0, async_context_1.getCurrentAsyncContext)();
+    return (context === null || context === void 0 ? void 0 : context.userCodeLogs) || [];
+}

package/lib/utils/apm.config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = exports.APM_MEASUREMENT_NAME = void 0;
+exports.APM_MEASUREMENT_NAME = "vectorx_kit_agent_runtime";
+exports.defaultConfig = {
+    endpoint: "https://apm-fe.xiaohongshu.com/api/data",
+};

package/lib/utils/apm.js

@@ -0,0 +1,140 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.ApmReporter = void 0;
+const os = __importStar(require("os"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const uuid_1 = require("uuid");
+const apm_config_1 = require("./apm.config");
+const machineId_1 = require("./machineId");
+class ApmReporter {
+    constructor() {
+        this.seq = 1;
+        this.reportQueue = [];
+        this.timer = null;
+        this.reportQueue = [];
+        this.apmContext = {
+            context_nameTracker: "nodeT",
+            context_platform: os.platform(),
+            context_appVersion: "unknown",
+            context_osVersion: os.release(),
+            context_userAgent: `Node/${process.version} ${os.platform()}/${os.release()} (${os.arch()})`,
+            context_artifactName: "xhsmpcloudbase",
+            context_deviceModel: "",
+            context_matchedPath: "",
+            context_deviceId: (0, machineId_1.machineIdSync)(true),
+            context_package: "",
+            context_networkType: "unknown",
+            context_networkQuality: "unknown",
+        };
+    }
+    getSequence() {
+        return {
+            context_sdkSeqId: this.seq++,
+            context_sdkSessionId: (0, uuid_1.v4)(),
+            context_pageSessionId: (0, uuid_1.v4)(),
+            clientTime: Date.now(),
+        };
+    }
+    report(measurement_name, measurement_data = {}) {
+        const params = {
+            sequence: this.getSequence(),
+            measurement_name,
+            measurement_data,
+        };
+        if (!Array.isArray(this.reportQueue)) {
+            this.reportQueue = [];
+        }
+        this.reportQueue.push(params);
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        if (this.reportQueue.length >= 10) {
+            this.batchReport();
+        }
+        else {
+            this.timer = setTimeout(() => {
+                this.batchReport();
+            }, 200);
+        }
+    }
+    batchReport() {
+        if (this.reportQueue.length === 0) {
+            return;
+        }
+        const queue = [...this.reportQueue];
+        this.reportQueue = [];
+        while (queue.length) {
+            this._request(queue.splice(0, 5));
+        }
+    }
+    _request(params, retry = true) {
+        const list = Array.isArray(params) ? params : [params];
+        const merged = list.map((i) => {
+            return Object.assign(Object.assign(Object.assign({}, this.apmContext), i.sequence), { measurement_name: i.measurement_name, measurement_data: Object.assign({}, i.measurement_data) });
+        });
+        return (0, node_fetch_1.default)(apm_config_1.defaultConfig.endpoint, {
+            method: "post",
+            body: JSON.stringify(merged),
+            headers: {
+                accept: "*/*",
+                "accept-language": "zh-CN,zh;q=0.9",
+                batch: "true",
+                "biz-type": "apm_fe",
+                "cache-control": "no-cache",
+                "content-type": "application/json",
+                pragma: "no-cache",
+            },
+        })
+            .then((res) => res.json())
+            .then((res) => {
+            if (res === null || res === void 0 ? void 0 : res.success) {
+            }
+            else {
+                throw new Error((res === null || res === void 0 ? void 0 : res.msg) || "APM request failed");
+            }
+        })
+            .catch((err) => {
+            if (retry) {
+                setTimeout(() => this._request(params, false), 1000);
+            }
+            process.stdout.write(`[⚡️] apm send failed: ${(err === null || err === void 0 ? void 0 : err.message) || null}`);
+        });
+    }
+}
+exports.ApmReporter = ApmReporter;

package/lib/utils/common.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGS_QUERY_REG = exports.AGENT_HEALTH_REG = void 0;
+exports.AGENT_HEALTH_REG = /\/v1\/aiagent\/agents\/([^\/]+)\/health/;
+exports.LOGS_QUERY_REG = /\/@logs/;

package/lib/utils/console-intercept.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interceptor = void 0;
+const console_1 = require("console");
+const stream_1 = require("stream");
+const util_1 = require("util");
+const async_context_1 = require("../async-context");
+const user_logger_1 = require("../user-logger");
+const error_stack_1 = require("./error-stack");
+const consoleMethods = ["debug", "info", "log", "trace", "warn", "error"];
+class EmptyWritableStream extends stream_1.Writable {
+    _write(_chunk, _encoding, callback) {
+        callback();
+    }
+}
+const emptyWritableStream = new EmptyWritableStream();
+class Interceptor {
+    constructor() { }
+    static intercept() {
+        Interceptor.interceptConsole();
+    }
+    static interceptConsole() {
+        function callAddUserCodeLog(level, message, ...optionalParams) {
+            if ((0, async_context_1.isInFrameworkAsyncContext)()) {
+                const log = {
+                    "@timestamp": new Date().toISOString(),
+                    caller: (0, error_stack_1.getCaller)(callAddUserCodeLog),
+                    level: level,
+                    content: (0, error_stack_1.truncateContent)((0, util_1.formatWithOptions)({ colors: false }, message, ...optionalParams)),
+                };
+                (0, user_logger_1.addUserCodeLog)(log);
+            }
+        }
+        const anotherConsole = new console_1.Console({
+            stdout: emptyWritableStream,
+            stderr: emptyWritableStream,
+            colorMode: false,
+            groupIndentation: 2,
+            inspectOptions: {},
+        });
+        const originalConsole = global.console;
+        for (const method of consoleMethods) {
+            anotherConsole[method] = (message, ...optionalParams) => {
+                if ((0, async_context_1.isInFrameworkAsyncContext)()) {
+                    callAddUserCodeLog(method, message, ...optionalParams);
+                    process.stdout.write((0, util_1.formatWithOptions)({ colors: false }, message, ...optionalParams));
+                }
+                else {
+                    originalConsole[method](message, ...optionalParams);
+                    process.stdout.write((0, util_1.formatWithOptions)({ colors: false }, message, ...optionalParams));
+                }
+            };
+        }
+        global.originalConsole = global.console;
+        global.console = anotherConsole;
+    }
+}
+exports.Interceptor = Interceptor;

package/lib/utils/error-stack.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCaller = getCaller;
+exports.formatCallSite = formatCallSite;
+exports.getStackTraces = getStackTraces;
+exports.truncateContent = truncateContent;
+const USER_CODE_LOGS_MAX_CONTENT_LENGTH = 1000;
+function getCaller(belowFn = null, index = 1) {
+    const stackTraces = getStackTraces(belowFn);
+    return formatCallSite(stackTraces[index]);
+}
+function formatCallSite(stackTrace) {
+    return `at ${stackTrace.getFunctionName() || "<anonymous>"} (${stackTrace.getFileName()}:${stackTrace.getLineNumber()}:${stackTrace.getColumnNumber()})`;
+}
+function getStackTraces(belowFn = null) {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (dummyObject, stackTraces) => stackTraces;
+    const dummyObject = { stack: [] };
+    Error.captureStackTrace(dummyObject, belowFn || getStackTraces);
+    const stackTraces = dummyObject.stack;
+    Error.prepareStackTrace = originalPrepareStackTrace;
+    return stackTraces;
+}
+function truncateContent(content) {
+    if (content.length > USER_CODE_LOGS_MAX_CONTENT_LENGTH) {
+        return (content.slice(0, USER_CODE_LOGS_MAX_CONTENT_LENGTH) +
+            `... ${content.length - USER_CODE_LOGS_MAX_CONTENT_LENGTH} more characters`);
+    }
+    return content;
+}