@coherentglobal/wasm-runner 0.1.4 → 0.2.4

package/dist/node.js

@@ -15,35 +15,30 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+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.WasmRunner = exports.ModelExecuteCancelled = exports.CancellationToken = exports.ColumnarSerializer = void 0;
-/* eslint-disable consistent-return */
-/* eslint-disable no-shadow */
-/* eslint-disable camelcase */
-/* eslint-disable no-param-reassign */
-/* eslint-disable no-underscore-dangle */
 const tmp_1 = __importDefault(require("tmp"));
 const cuid2_1 = require("@paralleldrive/cuid2");
-const logger_1 = __importDefault(require("./node/logger"));
 const unzipper_1 = require("unzipper");
 const ejs_1 = __importDefault(require("ejs"));
 const stream_1 = __importStar(require("stream"));
@@ -51,11 +46,16 @@ const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const got_1 = __importDefault(require("got"));
+const semver_1 = __importDefault(require("semver"));
+const events_1 = __importDefault(require("events"));
+const node_os_1 = require("node:os");
 const workerPool_1 = __importDefault(require("./node/threads/workerPool"));
 const utils = __importStar(require("./utils"));
+const types_1 = require("./types");
 const error_1 = __importDefault(require("./error"));
-const node_os_1 = require("node:os");
 const constants_1 = require("./constants");
+const responseTimeMetric_1 = __importDefault(require("./responseTimeMetric"));
+const logger_1 = __importDefault(require("./node/logger"));
 /* istanbul ignore next  */
 var columnarSerializer_1 = require("./serializer/columnarSerializer");
 Object.defineProperty(exports, "ColumnarSerializer", { enumerable: true, get: function () { return columnarSerializer_1.ColumnarSerializer; } });
@@ -63,17 +63,16 @@ var CancellationToken_1 = require("./CancellationToken");
 Object.defineProperty(exports, "CancellationToken", { enumerable: true, get: function () { return CancellationToken_1.CancellationToken; } });
 var error_2 = require("./error");
 Object.defineProperty(exports, "ModelExecuteCancelled", { enumerable: true, get: function () { return error_2.ModelExecuteCancelled; } });
+tmp_1.default.setGracefulCleanup();
 const platformUsed = (0, node_os_1.platform)();
 const pipeline = (0, util_1.promisify)(stream_1.default.pipeline);
-function replaceRegexInFile(file, search, replace) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let contents = yield fs_1.default.promises.readFile(file, "utf8");
-        let replaced_contents = contents.replace(search, replace);
-        let tmpfile = `${file}-${(0, cuid2_1.createId)()}.jstmpreplace`;
-        yield fs_1.default.promises.writeFile(tmpfile, replaced_contents, "utf8");
-        yield fs_1.default.promises.rename(tmpfile, file);
-        return true;
-    });
+async function replaceRegexInFile(file, search, replace) {
+    const contents = await fs_1.default.promises.readFile(file, "utf8");
+    const replaced_contents = contents.replace(search, replace);
+    const tmpfile = `${file}-${(0, cuid2_1.createId)()}.jstmpreplace`;
+    await fs_1.default.promises.writeFile(tmpfile, replaced_contents, "utf8");
+    await fs_1.default.promises.rename(tmpfile, file);
+    return true;
 }
 /* istanbul ignore next  */
 const toWindowsPath = (fileLocation) => fileLocation.split(path_1.default.sep).join("//");
@@ -93,7 +92,7 @@ const unzipFiles = (id, url, workerFolder) => {
     let data;
     let metadata;
     let formspec;
-    // @ts-ignore
+    let compilerLog;
     const stream = fs_1.default.createReadStream(url).pipe((0, unzipper_1.Parse)());
     return new Promise((resolve, reject) => {
         stream.on("entry", (entry) => {
@@ -116,6 +115,9 @@ const unzipFiles = (id, url, workerFolder) => {
                 if (entry.path.toLowerCase().indexOf("_jsonformspec.json") > -1) {
                     formspec = fileName;
                 }
+                if (entry.path.toLowerCase().indexOf("_compilerlog.json") > -1) {
+                    compilerLog = fileName;
+                }
                 return entry.pipe(writeStream);
             }
             return entry.autodrain();
@@ -132,6 +134,7 @@ const unzipFiles = (id, url, workerFolder) => {
                     data,
                     metadata,
                     formspec,
+                    compilerLog,
                 });
         });
         stream.on("error", (error) => reject(error));
@@ -141,41 +144,59 @@ const template = ejs_1.default.compile(fs_1.default.readFileSync(path_1.default.
     encoding: "utf8",
     flag: "r",
 }), { async: false });
-const delay = (time) => {
-    return new Promise((res) => {
-        setTimeout(res, time);
-    });
-};
+const delay = (time) => new Promise((res) => {
+    setTimeout(res, time);
+});
 /**
  * WasmRunner class, responsible for managing model and it's lifecycle
  *
  * @class
  * @classdesc WasmRunner class, responsible for managing model and it's lifecycle
  */
-// eslint-disable-next-line import/prefer-default-export
-class WasmRunner {
+class WasmRunner extends events_1.default {
+    _tempWorkerFolder;
+    _tempModelFolder;
+    license;
+    models;
+    externalResolverModule;
+    initializingModels;
+    options;
+    safeCompiler;
+    logger;
     /**
      * Create new Wasm Runner instance
      *
      * @param {RunnerConfig} wasmRunnerConfig
      */
-    constructor(wasmRunnerConfig, externalResolverModule = "", license = "") {
+    constructor(wasmRunnerConfig, externalResolverModule = "", options = {}, license = "") {
+        super();
+        let baseTmpDir = null;
+        if (process.env.DEV_DEBUG_TMP_PATH) {
+            baseTmpDir = path_1.default.join(process.cwd(), process.env.DEV_DEBUG_TMP_PATH);
+        }
+        if (options.tmpDir) {
+            baseTmpDir = options.tmpDir;
+        }
         this._tempWorkerFolder = tmp_1.default.dirSync({
             prefix: "wasmserver_worker",
-            // @ts-ignore
             mode: 0o750,
+            tmpdir: baseTmpDir,
         });
         this._tempModelFolder = tmp_1.default.dirSync({
             prefix: "wasmserver_model",
-            // @ts-ignore
             mode: 0o750,
+            tmpdir: baseTmpDir,
         });
         this.license = license;
         this.initializingModels = [];
+        /* eslint-disable @typescript-eslint/no-require-imports */
         this.externalResolverModule = externalResolverModule
-            ? require.resolve(externalResolverModule)
-            : require.resolve("./defaultExternalResolver");
+            ? require(useCorrectPath(require.resolve(externalResolverModule)))
+            : require(require.resolve("./defaultExternalResolver"));
+        /* eslint-enable @typescript-eslint/no-require-imports */
         this.models = [];
+        this.options = options;
+        this.logger = this.options.logger || logger_1.default;
         if (!utils.isEmpty(wasmRunnerConfig)) {
             if (Array.isArray(wasmRunnerConfig)) {
                 this.models = wasmRunnerConfig.map((wsconfig) => ({
@@ -200,190 +221,292 @@ class WasmRunner {
      * @function initialize
      */
     /* istanbul ignore next  */
-    initialize(license = "") {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(this.models.map((m) => __awaiter(this, void 0, void 0, function* () {
-                return this._initializeModelInstance(m);
-            })));
-        });
+    async initialize(license = "") {
+        if (this.options.compatibilityCheckEnabled) {
+            this.safeCompiler = await this.getSafeCompilerVersion(this.options.runnerVersion);
+        }
+        await Promise.all(this.models.map(async (m) => this._initializeModelInstance(m)));
     }
     /* istanbul ignore next  */
-    _createModelInstance(id, url, workerFolder, size) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.default.debug({
-                TimeStamp: Date.now(),
-                EventType: "Runner._createModelInstance",
-                size: size,
-                ModelId: id,
-            });
-            const tempFolder = path_1.default.join(workerFolder, `${id}-${Date.now()}`);
-            try {
-                yield fs_1.default.promises.mkdir(tempFolder, { mode: 0o750 });
-            }
-            catch (err) {
-                logger_1.default.info(`${tempFolder} existed`);
-            }
-            const modelPack = yield unzipFiles(id, url, tempFolder);
-            logger_1.default.debug({
-                TimeStamp: Date.now(),
-                EventType: "Runner.UnZipFiles",
-                ModelId: id,
-            });
-            const modelName = id;
-            yield replaceRegexInFile(modelPack.js, `wasmBinaryFile="${path_1.default.basename(modelPack.wasm)}"`, `scriptDirectory="";wasmBinaryFile="${modelPack.wasm}"`);
-            if (modelPack.data) {
-                yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
-                yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
-                yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
-                yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
-            }
-            // Prepare File Paths
-            const externalResolverPath = useCorrectPath(this.externalResolverModule);
-            const loggerPath = useCorrectPath(process.env.NODE_ENV === "test"
-                ? require.resolve("./node/mockLogger.js")
-                : require.resolve("./node/logger"));
-            const workerThread = useCorrectPath(process.env.NODE_ENV === "test"
-                ? require.resolve("./node/threads/mockWorkerThread.js")
-                : require.resolve("./node/threads/workerThread"));
-            let metadata = "undefined";
-            if (!utils.isEmpty(modelPack.metadata)) {
-                const metadataPath = useCorrectPath(require.resolve(modelPack.metadata));
-                metadata = `require("${metadataPath}")`;
-            }
-            let formspec = "undefined";
-            if (!utils.isEmpty(modelPack.formspec)) {
-                const formSpecPath = useCorrectPath(require.resolve(modelPack.formspec));
-                formspec = `require("${formSpecPath}")`;
+    async _createModelInstance(id, url, workerFolder, size = 1) {
+        const workerSize = size || 1;
+        this.logger.debug({
+            TimeStamp: Date.now(),
+            EventType: "Runner._createModelInstance",
+            size: workerSize,
+            ModelId: id,
+        });
+        const tempFolder = path_1.default.join(workerFolder, `${id}-${Date.now()}`);
+        try {
+            await fs_1.default.promises.mkdir(tempFolder, { mode: 0o750 });
+        }
+        catch (_err) {
+            this.logger.info(`${tempFolder} existed`);
+        }
+        const modelPack = await unzipFiles(id, url, tempFolder);
+        this.logger.debug({
+            TimeStamp: Date.now(),
+            EventType: "Runner.UnZipFiles",
+            ModelId: id,
+        });
+        const modelName = id;
+        await replaceRegexInFile(modelPack.js, `wasmBinaryFile="${path_1.default.basename(modelPack.wasm)}"`, `scriptDirectory="";wasmBinaryFile="${modelPack.wasm}"`);
+        const replaceIsFileURLFunc = "function isFileURI(filename) { if(typeof process !== undefined && process.versions && process.versions.node) { return true; }";
+        await replaceRegexInFile(modelPack.js, "function isFileURI(filename) {", replaceIsFileURLFunc);
+        await replaceRegexInFile(modelPack.js, "function isFileURI(filename){", replaceIsFileURLFunc);
+        // Remove `new URL()` since `isFileURI` will always be true for Node
+        await replaceRegexInFile(modelPack.js, /\s*isFileURI\s*\(\s*filename\s*\)\s*\?\s*new\s*URL\s*\(\s*filename\s*\)\s*:\s*/g, "");
+        if (modelPack.data) {
+            await replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
+            await replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
+            await replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
+            await replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
+        }
+        // Prepare File Paths
+        // const externalResolverPath = useCorrectPath(this.externalResolverModule);
+        const loggerPath = useCorrectPath(process.env.NODE_ENV === "test"
+            ? require.resolve("./node/mockLogger.js")
+            : require.resolve("./node/logger"));
+        const workerThread = useCorrectPath(process.env.NODE_ENV === "test"
+            ? require.resolve("./node/threads/mockWorkerThread.js")
+            : require.resolve("./node/threads/workerThread"));
+        let metadata = "undefined";
+        if (!utils.isEmpty(modelPack.metadata)) {
+            const metadataPath = useCorrectPath(require.resolve(modelPack.metadata));
+            metadata = `require("${metadataPath}")`;
+        }
+        let formspec = "undefined";
+        if (!utils.isEmpty(modelPack.formspec)) {
+            const formSpecPath = useCorrectPath(require.resolve(modelPack.formspec));
+            formspec = `require("${formSpecPath}")`;
+        }
+        let compilerVersion = "undefined";
+        let compatibilityStatus = "undefined";
+        compilerVersion = !utils.isEmpty(modelPack.compilerLog)
+            ? await this.getNeuronCompilerVersion(`"${modelPack.compilerLog}"`)
+            : undefined;
+        if (this.options.compatibilityCheckEnabled) {
+            compatibilityStatus =
+                await this.checkCompilerVersionCompatibility(compilerVersion);
+        }
+        const fileContent = template({
+            runtime: modelPack.js.replace(".js", ""),
+            model: modelPack.wasm,
+            metadata,
+            formspec,
+            modelName,
+            modules: {
+                logger: loggerPath,
+                workerThread: workerThread,
+            },
+        });
+        const workerPath = path_1.default.join(tempFolder, `worker-${id}.js`);
+        await fs_1.default.promises.writeFile(workerPath, fileContent);
+        this.logger.debug({
+            TimeStamp: Date.now(),
+            EventType: "Runner.CreateTemplates",
+            ModelId: id,
+        });
+        let workerPool;
+        let reportedStats = 0;
+        /**
+         * Processes the requests from Worker thread. Interprets the request
+         * `type` and implement necessary logic and returns the result.
+         *
+         * @param {Object} requestData
+         * Event details from Worker thread.
+         */
+        const processWorkerThreadRequest = async (requestData) => {
+            const { type, payload, context, threadId } = requestData;
+            // Worker request of model execution on main thread.
+            if (type === constants_1.THREAD_EVENT_TYPES.REQUEST_EXECUTE) {
+                try {
+                    // Callback the resolver function
+                    const result = await this.externalResolverModule.sparkService(payload, context);
+                    // Send back the response to worker thread
+                    workerPool.postMessage({
+                        payload: result,
+                        type: constants_1.THREAD_EVENT_TYPES.RESPONSE,
+                        threadId,
+                    });
+                }
+                catch (e) {
+                    // Send back the error to worker thread
+                    workerPool.postMessage({
+                        payload: e,
+                        type: constants_1.THREAD_EVENT_TYPES.ERROR,
+                        threadId,
+                    });
+                }
             }
-            const fileContent = template({
-                runtime: modelPack.js.replace(".js", ""),
-                model: modelPack.wasm,
-                metadata,
-                formspec,
-                modelName,
-                modules: {
-                    externalResolver: externalResolverPath,
-                    logger: loggerPath,
-                    workerThread: workerThread,
-                },
-            });
-            const workerPath = path_1.default.join(tempFolder, `worker-${id}.js`);
-            yield fs_1.default.promises.writeFile(workerPath, fileContent);
-            logger_1.default.debug({
-                TimeStamp: Date.now(),
-                EventType: "Runner.CreateTemplates",
-                ModelId: id,
-            });
-            /**
-             * Processes the requests from Worker thread. Interprets the request
-             * `type` and implement necessary logic and returns the result.
-             *
-             * @param {Object} requestData
-             * Event details from Worker thread.
-             */
-            const processWorkerThreadRequest = (requestData) => __awaiter(this, void 0, void 0, function* () {
-                const { type, payload, eventId, context } = requestData;
-                // Worker request of model execution on main thread.
-                if (type === constants_1.THREAD_EVENT_TYPES.REQUEST_EXECUTE) {
-                    try {
-                        const resolverModule = require(this.externalResolverModule);
-                        // Callback the resolver function
-                        const result = yield resolverModule.sparkService(payload, context);
-                        // Send back the response to worker thread
-                        workerPool.postMessage({
-                            payload: result,
-                            type: constants_1.THREAD_EVENT_TYPES.RESPONSE,
-                            eventId,
-                        });
+            if (type === constants_1.THREAD_EVENT_TYPES.STATS_REPORT) {
+                const { payload, threadId } = requestData;
+                const worker = this.models.find((m) => m.id === workerPool.id);
+                if (!worker) {
+                    // Worker has been removed and this is a stale report
+                    return;
+                }
+                // Initialize stats object if it doesn't exist
+                if (!worker.stats) {
+                    worker.stats = {};
+                }
+                // Initialize stats for threadId if it doesn't exist
+                if (!worker.stats[threadId]) {
+                    worker.stats[threadId] = {
+                        init_memory: 0,
+                        init_time_ms: 0,
+                        ready_ts: Date.now(),
+                        peak_memory: 0,
+                        current_memory: 0,
+                        last_execute_consume_memory: 0,
+                    };
+                }
+                if (worker && worker.stats && worker.stats[threadId]) {
+                    worker.stats[threadId].current_memory = payload.memoryUsage;
+                    if (payload.memoryUsage > worker.stats[threadId].peak_memory) {
+                        worker.stats[threadId].peak_memory = payload.memoryUsage;
                     }
-                    catch (e) {
-                        // Send back the error to worker thread
-                        workerPool.postMessage({
-                            payload: e,
-                            type: constants_1.THREAD_EVENT_TYPES.ERROR,
-                            eventId,
-                        });
+                    reportedStats += 1;
+                    if (reportedStats >= workerSize) {
+                        reportedStats = 0;
+                        setTimeout(() => {
+                            if (!this.isExist(workerPool.id)) {
+                                return;
+                            }
+                            this.emit("worker_report_stats", {
+                                id: workerPool.id,
+                                thread_stats: worker.stats,
+                                current_memory: Object.values(worker.stats)
+                                    .map((thread) => {
+                                    if (utils.isNumber(thread.current_memory)) {
+                                        return thread.current_memory;
+                                    }
+                                    return 0;
+                                })
+                                    .reduce((sum, memory) => sum + memory, 0),
+                            });
+                        }, 10);
                     }
                 }
-            });
-            const workerPool = new workerPool_1.default(size || 1, workerPath, {
-                errorHandler: (e) => logger_1.default.error("Worker Error: ", e),
-                // Receive messages from worker here
-                messageHandler: processWorkerThreadRequest,
-            });
-            logger_1.default.debug({
-                TimeStamp: Date.now(),
-                EventType: "Runner.ModelInitialize",
-                ModelId: id,
-            });
-            return new Promise((resolve, reject) => {
-                let limit = 0;
-                const checkModelStatus = () => __awaiter(this, void 0, void 0, function* () {
-                    const isReady = yield workerPool.execute("isReady");
-                    if (isReady) {
-                        logger_1.default.debug({
-                            TimeStamp: Date.now(),
-                            EventType: "Runner.ModelInitialize.Completed",
-                            ModelId: id,
+            }
+        };
+        const workerName = path_1.default.basename(modelPack.js, path_1.default.extname(modelPack.js)) || "";
+        workerPool = new workerPool_1.default(id, workerSize, workerPath, {
+            errorHandler: (e) => logger_1.default &&
+                logger_1.default.error({
+                    EventType: "Worker.Error",
+                    Error: e,
+                    ModelId: id,
+                    TextMessage: e.message,
+                }, "Worker Error"),
+            onlineHandler: () => logger_1.default &&
+                logger_1.default.info({ EventType: "Worker.Online", ModelId: id }, `Worker ${id} online`),
+            // Receive messages from worker here
+            messageHandler: processWorkerThreadRequest,
+            workerOptions: {
+                name: workerName,
+            },
+        });
+        this.logger.debug({
+            TimeStamp: Date.now(),
+            EventType: "Runner.ModelInitialize",
+            ModelId: id,
+        });
+        return new Promise((resolve, reject) => {
+            let limit = 0;
+            let readyCount = workerSize;
+            const stats = {};
+            const checkModelStatus = async () => {
+                const readyRes = await workerPool.execute("isReady");
+                if (readyRes && !stats[readyRes.threadId]) {
+                    stats[readyRes.threadId] = {
+                        init_memory: readyRes.memoryUsage,
+                        init_time_ms: readyRes.time,
+                        ready_ts: readyRes.payload?.readyTs || readyRes.readyTs,
+                        peak_memory: readyRes.memoryUsage,
+                        last_execute_consume_memory: readyRes.memoryUsage,
+                    };
+                    readyCount -= 1;
+                    this.logger.debug({
+                        TimeStamp: Date.now(),
+                        EventType: "Runner.ModelInitialize.Completed",
+                        ModelId: id,
+                    });
+                    if (readyCount === 0) {
+                        resolve({
+                            instance: workerPool,
+                            compilerVersion,
+                            compatibilityStatus,
+                            size: workerSize,
+                            stats: stats,
                         });
-                        resolve(workerPool);
-                    }
-                    else if (limit >= 2000) {
-                        // 1 second
-                        reject(new Error("Model initialize issue"));
                     }
                     else {
-                        setTimeout(checkModelStatus, 15);
-                        // eslint-disable-next-line no-plusplus
-                        limit++;
+                        setTimeout(checkModelStatus, 1);
                     }
-                });
-                setTimeout(checkModelStatus, 15);
-            });
+                }
+                else if (limit >= 2000) {
+                    // 1 second
+                    reject(new Error("Model initialize issue"));
+                }
+                else {
+                    setTimeout(checkModelStatus, 15);
+                    limit++;
+                }
+            };
+            setTimeout(checkModelStatus, 15);
         });
     }
     /* istanbul ignore next  */
-    _initializeModelInstance(m) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (utils.isHttpURL(m.url)) {
-                const instance = yield this._createModelInstanceFromURL(m.id, m.url, this._tempWorkerFolder.name, this._tempModelFolder.name, m.size);
-                m.ready = true;
-                m.worker = instance;
-                return Promise.resolve();
-            }
-            if (yield utils.isPath(m.url)) {
-                const instance = yield this._createModelInstance(m.id, m.url, this._tempWorkerFolder.name, m.size);
-                m.ready = true;
-                m.worker = instance;
-                return Promise.resolve();
-            }
-            if (Buffer.isBuffer(m.url)) {
-                const model = stream_1.Readable.from(m.url);
-                const modelPath = path_1.default.join(this._tempWorkerFolder.name, `${m.id}.zip`);
-                const fileWriterStream = (0, fs_1.createWriteStream)(modelPath);
-                yield pipeline(model, fileWriterStream);
-                const instance = yield this._createModelInstance(m.id, modelPath, this._tempWorkerFolder.name, m.size);
-                m.ready = true;
-                m.worker = instance;
-                return Promise.resolve();
-            }
-        });
+    async _initializeModelInstance(m) {
+        if (utils.isHttpURL(m.url)) {
+            const { instance, compilerVersion, compatibilityStatus, stats } = await this._createModelInstanceFromURL(m.id, m.url, this._tempWorkerFolder.name, this._tempModelFolder.name, m.size);
+            m.ready = true;
+            m.worker = instance;
+            m.compatibility_status = compatibilityStatus;
+            m.compilerVersion = compilerVersion;
+            m.stats = stats;
+            m.responseTimeMetrics = new responseTimeMetric_1.default();
+            return Promise.resolve();
+        }
+        if (await utils.isPath(m.url)) {
+            const { instance, compilerVersion, compatibilityStatus, stats } = await this._createModelInstance(m.id, m.url, this._tempWorkerFolder.name, m.size);
+            m.ready = true;
+            m.worker = instance;
+            m.compatibility_status = compatibilityStatus;
+            m.compilerVersion = compilerVersion;
+            m.stats = stats;
+            m.responseTimeMetrics = new responseTimeMetric_1.default();
+            return Promise.resolve();
+        }
+        if (Buffer.isBuffer(m.url)) {
+            const model = stream_1.Readable.from(m.url);
+            const modelPath = path_1.default.join(this._tempWorkerFolder.name, `${m.id}.zip`);
+            const fileWriterStream = (0, fs_1.createWriteStream)(modelPath);
+            await pipeline(model, fileWriterStream);
+            const { instance, compilerVersion, compatibilityStatus, stats } = await this._createModelInstance(m.id, modelPath, this._tempWorkerFolder.name, m.size);
+            m.ready = true;
+            m.worker = instance;
+            m.compatibility_status = compatibilityStatus;
+            m.compilerVersion = compilerVersion;
+            m.stats = stats;
+            m.responseTimeMetrics = new responseTimeMetric_1.default();
+            return Promise.resolve();
+        }
     }
     /* istanbul ignore next  */
-    _createModelInstanceFromURL(id, url, workerFolder, modelFolder, size) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const modelPath = path_1.default.join(modelFolder, `${id}.zip`);
-                const downloadStream = got_1.default.stream(url);
-                const fileWriterStream = (0, fs_1.createWriteStream)(modelPath);
-                yield pipeline(downloadStream, fileWriterStream);
-                const instance = yield this._createModelInstance(id, modelPath, workerFolder, size);
-                return instance;
-            }
-            catch (err) {
-                throw new error_1.default.ModelError(`Error createModelInstanceFromURL: id:${id}, url:${url}, error:${err.message}`);
-            }
-        });
+    async _createModelInstanceFromURL(id, url, workerFolder, modelFolder, size) {
+        try {
+            const modelPath = path_1.default.join(modelFolder, `${id}.zip`);
+            const downloadStream = got_1.default.stream(url);
+            const fileWriterStream = (0, fs_1.createWriteStream)(modelPath);
+            await pipeline(downloadStream, fileWriterStream);
+            const instance = await this._createModelInstance(id, modelPath, workerFolder, size);
+            return instance;
+        }
+        catch (err) {
+            throw new error_1.default.ModelError(`Error createModelInstanceFromURL: id:${id}, url:${url}, error:${err.message}`);
+        }
     }
     /**
      * Append and initialize model in preparation for the `execute()`.
@@ -393,43 +516,44 @@ class WasmRunner {
      *
      * @returns {Promise<void>}
      */
-    append(modelConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async append(modelConfig) {
+        if (this.options.compatibilityCheckEnabled) {
+            this.safeCompiler = await this.getSafeCompilerVersion(this.options.runnerVersion);
+        }
+        if (!this.isExist(modelConfig.id)) {
+            const model = {
+                id: modelConfig.id,
+                url: modelConfig.url,
+                size: modelConfig.size,
+                busy: 0,
+            };
             if (!this.isExist(modelConfig.id)) {
-                const model = {
-                    id: modelConfig.id,
-                    url: modelConfig.url,
-                    size: modelConfig.size,
-                    busy: 0,
-                };
-                if (!this.isExist(modelConfig.id)) {
-                    if (this.initializingModels.findIndex((im) => im === modelConfig.id) === -1) {
-                        try {
-                            this.initializingModels.push(modelConfig.id);
-                            yield this._initializeModelInstance(model);
-                            this.models.push(model);
-                        }
-                        catch (e) {
-                            throw e;
-                        }
-                        finally {
-                            this.initializingModels = this.initializingModels.filter((im) => im !== modelConfig.id);
-                        }
+                if (this.initializingModels.findIndex((im) => im === modelConfig.id) ===
+                    -1) {
+                    try {
+                        this.initializingModels.push(modelConfig.id);
+                        await this._initializeModelInstance(model);
+                        this.models.push(model);
                     }
-                    else {
-                        const maxRetry = 600;
-                        let retry = 0;
-                        while (this.initializingModels.findIndex((im) => im === modelConfig.id) > -1 && retry < maxRetry) {
-                            yield delay(100);
-                            retry++;
-                        }
-                        if (retry >= maxRetry || !this.isExist(modelConfig.id)) {
-                            throw new error_1.default.ModelInitializationError(modelConfig.id);
-                        }
+                    finally {
+                        this.initializingModels = this.initializingModels.filter((im) => im !== modelConfig.id);
+                    }
+                }
+                else {
+                    const maxRetry = 600;
+                    let retry = 0;
+                    while (this.initializingModels.findIndex((im) => im === modelConfig.id) >
+                        -1 &&
+                        retry < maxRetry) {
+                        await delay(100);
+                        retry++;
+                    }
+                    if (retry >= maxRetry || !this.isExist(modelConfig.id)) {
+                        throw new error_1.default.ModelInitializationError(modelConfig.id);
                     }
                 }
             }
-        });
+        }
     }
     /**
      * Remove model from the list of initialized model useful for GC.
@@ -439,21 +563,20 @@ class WasmRunner {
      *
      * @returns {Promise<void>}
      */
-    remove(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isExist(id)) {
-                const model = this.models.find((m) => m.id === id);
-                yield model.worker.execute("destroy");
+    async remove(id) {
+        if (this.isExist(id)) {
+            const model = this.models.find((m) => m.id === id);
+            this.models = this.models.filter((m) => m.id !== id);
+            setImmediate(async () => {
+                await model.worker.execute("destroy");
                 model.worker.destroy();
                 delete model.worker;
-                this.models = this.models.filter((m) => m.id !== id);
-            }
-        });
+            });
+        }
     }
     /* istanbul ignore next  */
     _parseError(rawResponse) {
-        var _a;
-        let errors = (_a = rawResponse.response_data) === null || _a === void 0 ? void 0 : _a.errors.reduce((prev, curr) => {
+        let errors = rawResponse.response_data?.errors.reduce((prev, curr) => {
             const { source_path } = curr;
             if (!source_path) {
                 return prev;
@@ -504,6 +627,17 @@ class WasmRunner {
             throw new error_1.default.ModelInitializationError(id);
         return model;
     }
+    getModelSize(id) {
+        const model = this._getModel(id);
+        return model.size || 1;
+    }
+    getModelCompilerVersion(id) {
+        const model = this._getModel(id);
+        if (model.compilerVersion && model.compilerVersion !== "undefined") {
+            return model.compilerVersion;
+        }
+        return undefined;
+    }
     /**
      * Check if model existed
      * @param {string} id Model id
@@ -513,104 +647,241 @@ class WasmRunner {
         try {
             return !!this._getModel(id);
         }
-        catch (err) {
+        catch (_err) {
             return false;
         }
     }
+    isModelCompatible(model, input) {
+        if (!this.options.compatibilityCheckEnabled) {
+            return true;
+        }
+        switch (model.compatibility_status) {
+            case types_1.Compatibility.INCOMPATIBLE:
+                throw new error_1.default.ModelExecuteError(this.getIncompatibleMessage(model), model.id, input);
+            case types_1.Compatibility.PARTIAL:
+                this.logger.warn({
+                    TimeStamp: Date.now(),
+                    EventType: "Runner.Execute.Compatibility.Warning",
+                    TextMessage: this.getPartiallyCompatibleMessage(model),
+                    ModelId: model.id,
+                });
+                return true;
+            case types_1.Compatibility.COMPATIBLE:
+                return true;
+            default:
+                return true;
+        }
+    }
+    getModelsStats() {
+        return this.models.map((model) => {
+            const stats = { ...model.stats };
+            Object.keys(stats).forEach((threadId) => {
+                stats[threadId] = { ...stats[threadId] };
+                Object.keys(stats[threadId]).forEach((k) => {
+                    if (k.indexOf("_memory") > -1) {
+                        stats[threadId][`${k}_mb`] = utils.formatMemory(stats[threadId][k]);
+                        delete stats[threadId][k];
+                    }
+                    if (k.indexOf("ready_ts") > -1) {
+                        stats[threadId].uptime_ms = Date.now() - stats[threadId].ready_ts;
+                        delete stats[threadId][k];
+                    }
+                });
+            });
+            return {
+                thread_stats: {
+                    ...stats,
+                },
+                memory_usage_mb: Object.values(stats)
+                    .map((thread) => thread.current_memory_mb || 0)
+                    .reduce((sum, memory) => sum + memory, 0),
+                uptime_ms: Math.min(...Object.keys(stats).map((k) => stats[k].uptime_ms)),
+                min_time_ms: model.responseTimeMetrics.min,
+                mean_time_ms: model.responseTimeMetrics.mean,
+                p95_time_ms: model.responseTimeMetrics.p95,
+                p99_time_ms: model.responseTimeMetrics.p99,
+                max_time_ms: model.responseTimeMetrics.max,
+                busy: model.busy,
+                size: model.size,
+                id: model.id,
+            };
+        });
+    }
+    getPartiallyCompatibleMessage(model) {
+        return `The Wasm was compiled using ${model.compilerVersion} which is not fully supported by this runner version ${this.safeCompiler}. The service should be able to run but could encounter errors`;
+    }
+    getIncompatibleMessage(model) {
+        return `The Wasm was compiled using ${model.compilerVersion} which is not supported by this runner version ${this.safeCompiler}.`;
+    }
     /**
      * Perform calculation. The runner will use request_meta.version_uuid of input argument to locate model
      * @async
      * @param {InputObject} input - Input data for calculation
      * @returns {Promise<ResponseObject>} - Response model data
      */
-    execute(input, id = undefined, raw = false, cancelToken) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            let logInput;
-            const token = cancelToken ? cancelToken.getToken() : undefined;
-            if (utils.isV3Input(input)) {
-                logInput = {
-                    request_data: {
-                        inputs: (_a = input === null || input === void 0 ? void 0 : input.request_data) === null || _a === void 0 ? void 0 : _a.inputs,
-                    },
-                    request_meta: Object.assign(Object.assign({}, input.request_meta), (input.request_meta._ctx ? { _ctx: "[REDACTED]" } : {})),
-                };
-                logger_1.default.trace(`EXECUTING: ${id}, input: ${JSON.stringify(logInput)}`);
-            }
-            else {
-                logger_1.default.trace(`EXECUTING: ${id}, input: ${JSON.stringify(input)}`);
-            }
-            const callid = input.callid || (0, cuid2_1.createId)();
-            const start = Date.now();
-            logger_1.default.debug({
+    async execute(input, id = undefined, raw = false, cancelToken) {
+        let logInput;
+        const token = cancelToken ? cancelToken.getToken() : undefined;
+        if (utils.isV3Input(input)) {
+            logInput = {
+                request_data: {
+                    inputs: input?.request_data?.inputs,
+                },
+                request_meta: {
+                    ...input.request_meta,
+                    ...(input.request_meta._ctx ? { _ctx: "[REDACTED]" } : {}),
+                },
+            };
+            this.logger.trace({
+                TimeStamp: Date.now(),
+                EventType: "Runner.Execute.V3",
+                TextMessage: `EXECUTING`,
+                JSONPayload: { input: logInput, modelId: id },
+            });
+        }
+        else {
+            this.logger.trace({
                 TimeStamp: Date.now(),
                 EventType: "Runner.Execute",
-                runnerCallId: callid,
-                ModelId: id,
+                TextMessage: `EXECUTING`,
+                JSONPayload: { input: input, modelId: id },
             });
-            const version_uuid = id ||
-                ((_b = input === null || input === void 0 ? void 0 : input.request_meta) === null || _b === void 0 ? void 0 : _b.version_uuid) ||
-                ((_c = input === null || input === void 0 ? void 0 : input.request_meta) === null || _c === void 0 ? void 0 : _c.version_id) ||
-                (input === null || input === void 0 ? void 0 : input.version_id);
-            if (input) {
-                if (raw) {
-                    if (!input.request_data) {
-                        input.request_data = {};
-                    }
-                    input.request_data._raw = true;
+        }
+        const callid = input.callid || (0, cuid2_1.createId)();
+        const version_uuid = id ||
+            input?.request_meta?.version_uuid ||
+            input?.request_meta?.version_id ||
+            input?.version_id;
+        if (input) {
+            if (raw) {
+                if (!input.request_data) {
+                    input.request_data = {};
                 }
-                const model = this._getModel(version_uuid);
-                try {
-                    if (!input.callid) {
-                        input.callid = callid;
-                    }
-                    if (model.busy < model.size) {
-                        model.busy = model.busy + 1;
-                    }
-                    else {
-                        while (model.busy >= model.size) {
-                            if (token) {
-                                token.throwIfCancelled(version_uuid, input);
-                            }
-                            yield new Promise((resolve) => setTimeout(resolve, 1));
-                            logger_1.default.debug({
-                                TimeStamp: Date.now(),
-                                EventType: "Runner.Execute.Waiting",
-                                runnerCallId: callid,
-                                ModelId: id,
-                            });
-                        }
-                        model.busy = model.busy + 1;
+                input.request_data._raw = true;
+            }
+            const model = this._getModel(version_uuid);
+            try {
+                if (!input.callid) {
+                    input.callid = callid;
+                }
+                this.logger.debug({
+                    TimeStamp: Date.now(),
+                    EventType: "Runner.Execute",
+                    TextMessage: `PREEXECUTING ${id}`,
+                    JSONPayload: {
+                        runnerCallId: callid,
+                        ModelId: id,
+                    },
+                });
+                if (this.isModelCompatible(model, input)) {
+                    const start = Date.now();
+                    if (token) {
+                        token.throwIfCancelled(version_uuid, input);
                     }
-                    let parsedResult;
-                    parsedResult = yield model.worker.execute(input);
-                    logger_1.default.debug({
+                    this.logger.debug({
+                        TimeStamp: Date.now(),
+                        EventType: "Runner.Execute",
+                        TextMessage: `START EXECUTING ${id}`,
+                        JSONPayload: {
+                            runnerCallId: callid,
+                            ModelId: id,
+                        },
+                    });
+                    const res = await model.worker.execute(input);
+                    const execTime = Date.now() - start;
+                    this.logger.debug({
                         TimeStamp: Date.now(),
                         EventType: "Runner.Execute.Completed",
-                        executeDuration: Date.now() - start,
-                        runnerCallId: callid,
-                        ModelId: id,
+                        TextMessage: `EXECUTE COMPLETED ${id}`,
+                        JSONPayload: {
+                            executeDuration: execTime,
+                            runnerCallId: callid,
+                            ModelId: id,
+                        },
                     });
-                    return parsedResult;
-                }
-                catch (err) {
-                    logger_1.default.error(err);
-                    if (err.name === "validation_error") {
-                        throw err;
+                    if (res.memoryUsage > model.stats[res.threadId].peak_memory) {
+                        model.stats[res.threadId].peak_memory = res.memoryUsage;
                     }
-                    if (err.name === "execution_cancelled") {
-                        throw err;
+                    model.stats[res.threadId].last_execute_consume_memory =
+                        res.memoryUsage;
+                    model.responseTimeMetrics.record(execTime);
+                    if (res.error) {
+                        throw res.error;
                     }
-                    throw new error_1.default.ModelExecuteError(err.message, version_uuid, input);
+                    return res.payload;
                 }
-                finally {
-                    model.busy = model.busy - 1;
+                throw new error_1.default.ModelExecuteError(this.getIncompatibleMessage(model), version_uuid, input);
+            }
+            catch (err) {
+                this.logger.error(err);
+                if (err.name === "validation_error") {
+                    throw err;
                 }
+                if (err.name === "execution_cancelled") {
+                    throw err;
+                }
+                throw new error_1.default.ModelExecuteError(err.message, version_uuid, input);
             }
-            else {
-                throw new error_1.default.ParameterRequiredError("request_meta.version_uuid", input);
+        }
+        else {
+            throw new error_1.default.ParameterRequiredError("request_meta.version_uuid", input);
+        }
+    }
+    async getNeuronCompilerVersion(logFile) {
+        let data;
+        let modelJsonInfo;
+        try {
+            data = fs_1.default.readFileSync(logFile.replace(/"/g, ""), "utf8");
+            modelJsonInfo = JSON.parse(data);
+        }
+        catch (err) {
+            this.logger.warn({
+                TimeStamp: Date.now(),
+                EventType: "Runner.GetNeuronCompilerVersion",
+                TextMessage: `Failed to get neuron compiler version from ${logFile}`,
+                JSONPayload: {
+                    error: err.message,
+                    logFile,
+                },
+            });
+            return undefined;
+        }
+        if (!semver_1.default.valid(modelJsonInfo.CompilerVersion)) {
+            throw new error_1.default.CompatibilityJsonError(`The Wasm was compiled using ${modelJsonInfo.CompilerVersion} which is not supported by the compatibility check.`);
+        }
+        const compilerVersion = semver_1.default.coerce(modelJsonInfo.CompilerVersion).version;
+        return compilerVersion;
+    }
+    async checkCompilerVersionCompatibility(modelCompilerVersion) {
+        try {
+            const safeCompilerVersion = this.safeCompiler;
+            if (modelCompilerVersion) {
+                if (semver_1.default.lte(modelCompilerVersion, safeCompilerVersion)) {
+                    return types_1.Compatibility.COMPATIBLE;
+                }
+                return types_1.Compatibility.PARTIAL;
             }
-        });
+            return types_1.Compatibility.COMPATIBLE;
+        }
+        catch (err) {
+            if (err.code === "ENOENT" || err.message === "File not found") {
+                return types_1.Compatibility.COMPATIBLE;
+            }
+            if (err instanceof SyntaxError) {
+                return types_1.Compatibility.INCOMPATIBLE;
+            }
+            throw err;
+        }
+    }
+    getSafeCompilerVersion(runnerVersion) {
+        const runnerVersions = this.options.compatibilityList?.runner_versions;
+        if (!this.options.compatibilityList) {
+            throw new error_1.default.CompatibilityJsonError("No runner compiler compatibility list provided");
+        }
+        if (!Object.prototype.hasOwnProperty.call(runnerVersions, runnerVersion)) {
+            throw new error_1.default.CompatibilityJsonError(`No compiler compatibility found for the runner version ${runnerVersion}`);
+        }
+        return runnerVersions[runnerVersion].safe_compiler;
     }
 }
 exports.WasmRunner = WasmRunner;