codeaura-embedded-runtime-agent 0.1.0

package/src/instrumentation/nodejs/wrappers/createEvent.js

@@ -0,0 +1,111 @@
+
+const EventSchema = require("../../../core/events/EventSchema"),
+    sanitizeInputs = require("../../../utils/sanitizeInputs"),
+    executionContext = require("../../../utils/executionContext");
+
+function createEvent(functionName, functionType, durationMs, executionId, args, result, error, controllerExecutionIdOverride, parentExecutionIdOverride) {
+    let meta = null,
+        inputs = null,
+        output = null,
+        req = null,
+        allParams = null,
+        path = null,
+        name = null,
+        lastSlashIndex = -1,
+        controllerExecutionId = null,
+        parentExecutionId = null;
+
+    meta = {
+        executionId,
+        argumentCount: args ? args.length : 0
+    };
+
+    path = functionName;
+    lastSlashIndex = functionName.lastIndexOf("/");
+
+    if (lastSlashIndex !== -1) {
+        name = functionName.substring(lastSlashIndex + 1);
+    } else {
+        name = functionName;
+    }
+
+    if (functionType === "controller" && args && args.length > 0) {
+        req = args[0];
+
+        if (req && typeof req.allParams === "function") {
+            try {
+                allParams = req.allParams();
+                inputs = sanitizeInputs(allParams);
+            } catch (unusedErr) {
+                inputs = null;
+            }
+        } else {
+            inputs = null;
+        }
+    } else if (functionType === "helper" && args && args.length > 0) {
+        inputs = sanitizeInputs(args[0]);
+        controllerExecutionId = controllerExecutionIdOverride !== undefined
+            ? controllerExecutionIdOverride
+            : executionContext.getControllerExecutionId();
+        parentExecutionId = parentExecutionIdOverride !== undefined
+            ? parentExecutionIdOverride
+            : executionContext.getCurrentExecutionId();
+    } else {
+        inputs = args && args.length > 0 ? sanitizeInputs(args[0]) : null;
+        controllerExecutionId = controllerExecutionIdOverride !== undefined
+            ? controllerExecutionIdOverride
+            : executionContext.getControllerExecutionId();
+        parentExecutionId = parentExecutionIdOverride !== undefined
+            ? parentExecutionIdOverride
+            : executionContext.getCurrentExecutionId();
+    }
+
+    if (!error && result !== undefined) {
+        output = sanitizeInputs(result);
+    } else {
+        output = null;
+    }
+
+    if (functionType === "controller") {
+        return EventSchema.createControllerEvent({
+            name: name,
+            durationMs,
+            meta,
+            inputs,
+            output,
+            path: path,
+            error,
+            controllerExecutionId: null,
+            parentExecutionId: null
+        });
+    }
+
+    if (functionType === "helper") {
+        return EventSchema.createHelperEvent({
+            name: name,
+            durationMs,
+            meta,
+            inputs,
+            output,
+            path: path,
+            error,
+            controllerExecutionId: controllerExecutionId,
+            parentExecutionId: parentExecutionId
+        });
+    }
+
+    return EventSchema.create({
+        type: functionType,
+        name: name,
+        durationMs,
+        meta,
+        inputs,
+        output,
+        path: path,
+        error,
+        controllerExecutionId: controllerExecutionId,
+        parentExecutionId: parentExecutionId
+    });
+}
+
+module.exports = createEvent;

package/src/instrumentation/nodejs/wrappers/handleAsyncFunction.js

@@ -0,0 +1,39 @@
+
+const createEvent = require("./createEvent");
+
+async function handleAsyncFunction(promise, startTime, executionId, functionName, functionType, args, buffer) {
+    try {
+        const result = await promise;
+
+        buffer.add(
+            createEvent(
+                functionName,
+                functionType,
+                Date.now() - startTime,
+                executionId,
+                args,
+                result,
+                null
+            )
+        );
+
+        return result;
+
+    } catch (error) {
+        buffer.add(
+            createEvent(
+                functionName,
+                functionType,
+                Date.now() - startTime,
+                executionId,
+                args,
+                undefined,
+                error
+            )
+        );
+
+        throw error;
+    }
+}
+
+module.exports = handleAsyncFunction;

package/src/instrumentation/nodejs/wrappers/index.js

@@ -0,0 +1,12 @@
+
+const { wrapFunction, getCallStatistics, resetCallStatistics } = require("./wrapFunction"),
+    wrapController = require("./wrapController"),
+    wrapHelper = require("./wrapHelper");
+
+module.exports = {
+    wrapFunction,
+    wrapController,
+    wrapHelper,
+    getCallStatistics,
+    resetCallStatistics
+};

package/src/instrumentation/nodejs/wrappers/wrapController.js

@@ -0,0 +1,42 @@
+
+const { wrapFunction, WRAPPED_FLAG, ORIGINAL_FUNCTION } = require("./wrapFunction");
+
+function isAlreadyWrapped(fn) {
+    return fn && fn[WRAPPED_FLAG] === true;
+}
+
+function wrapController(controller, controllerName, buffer, logger) {
+    let wrappedController = null;
+
+    if (controller && typeof controller === "object" && !isAlreadyWrapped(controller)) {
+        wrappedController = {};
+
+        for (const actionName of Object.keys(controller)) {
+            const action = controller[actionName];
+
+            wrappedController[actionName] =
+                typeof action === "function"
+                    ? wrapFunction(
+                        action,
+                        `${controllerName}/${actionName}`,
+                        "controller",
+                        buffer,
+                        logger
+                    )
+                    : action;
+        }
+
+        wrappedController[WRAPPED_FLAG] = true;
+        wrappedController[ORIGINAL_FUNCTION] = controller;
+    } else {
+        if (isAlreadyWrapped(controller)) {
+            logger.debug(`Controller ${controllerName} already wrapped`);
+        } else {
+
+        }
+    }
+
+    return wrappedController || controller;
+}
+
+module.exports = wrapController;

package/src/instrumentation/nodejs/wrappers/wrapFunction.js

@@ -0,0 +1,108 @@
+
+const EventSchema = require("../../../core/events/EventSchema"),
+    handleAsyncFunction = require("./handleAsyncFunction"),
+    createEvent = require("./createEvent"),
+    executionContext = require("../../../utils/executionContext"),
+    WRAPPED_FLAG = Symbol("__codeaura_wrapped__"),
+    ORIGINAL_FUNCTION = Symbol("__codeaura_original__");
+
+let functionCallCounts = {};
+
+function isAlreadyWrapped(fn) {
+    return fn && fn[WRAPPED_FLAG] === true;
+}
+
+function wrapFunction(originalFunction, functionName, functionType, buffer, unusedLogger) {
+    let wrappedFunction = null,
+        executionId = null,
+        startTime = 0,
+        result = null;
+
+    if (typeof originalFunction === "function" && !isAlreadyWrapped(originalFunction)) {
+        wrappedFunction = function (...args) {
+            executionId = EventSchema.generateId();
+            startTime = Date.now();
+
+            functionCallCounts[functionName] = (functionCallCounts[functionName] || 0) + 1;
+
+            try {
+                if (functionType === "controller") {
+                    result = executionContext.runAsController(executionId, () => originalFunction.apply(this, args));
+                } else {
+                    result = originalFunction.apply(this, args);
+                }
+
+                if (result && typeof result.then === "function") {
+                    return handleAsyncFunction(
+                        result,
+                        startTime,
+                        executionId,
+                        functionName,
+                        functionType,
+                        args,
+                        buffer
+                    );
+                } else {
+
+                }
+
+                buffer.add(
+                    createEvent(
+                        functionName,
+                        functionType,
+                        Date.now() - startTime,
+                        executionId,
+                        args,
+                        result,
+                        null
+                    )
+                );
+
+                return result;
+
+            } catch (error) {
+                buffer.add(
+                    createEvent(
+                        functionName,
+                        functionType,
+                        Date.now() - startTime,
+                        executionId,
+                        args,
+                        undefined,
+                        error
+                    )
+                );
+
+                throw error;
+            }
+        };
+
+        wrappedFunction[WRAPPED_FLAG] = true;
+        wrappedFunction[ORIGINAL_FUNCTION] = originalFunction;
+
+        Object.defineProperty(wrappedFunction, "name", {
+            value: originalFunction.name || functionName,
+            configurable: true
+        });
+    } else {
+
+    }
+
+    return wrappedFunction || originalFunction;
+}
+
+function getCallStatistics() {
+    return Object.assign({}, functionCallCounts);
+}
+
+function resetCallStatistics() {
+    functionCallCounts = {};
+}
+
+module.exports = {
+    wrapFunction,
+    getCallStatistics,
+    resetCallStatistics,
+    WRAPPED_FLAG,
+    ORIGINAL_FUNCTION
+};

package/src/instrumentation/nodejs/wrappers/wrapHelper.js

@@ -0,0 +1,86 @@
+
+const EventSchema = require("../../../core/events/EventSchema"),
+    { wrapFunction } = require("./wrapFunction"),
+    createEvent = require("./createEvent"),
+    executionContext = require("../../../utils/executionContext");
+
+function wrapHelper(helper, helperName, buffer, logger) {
+    let wrappedHelper = null;
+
+    try {
+        if (typeof helper === "function") {
+            wrappedHelper = wrapFunction(
+                helper,
+                helperName,
+                "helper",
+                buffer,
+                logger
+            );
+
+            if (typeof helper.with === "function") {
+                wrappedHelper.with = async function (inputs) {
+                    let executionId = null,
+                        startTime = 0,
+                        result = null,
+                        controllerExecutionId = null,
+                        parentExecutionId = null;
+
+                    executionId = EventSchema.generateId();
+                    startTime = Date.now();
+                    controllerExecutionId = executionContext.getControllerExecutionId();
+                    parentExecutionId = executionContext.getCurrentExecutionId();
+
+                    try {
+                        result = await helper.with(inputs);
+
+                        buffer.add(
+                            createEvent(
+                                helperName,
+                                "helper",
+                                Date.now() - startTime,
+                                executionId,
+                                [inputs],
+                                result,
+                                null,
+                                controllerExecutionId,
+                                parentExecutionId
+                            )
+                        );
+
+                        return result;
+
+                    } catch (error) {
+                        buffer.add(
+                            createEvent(
+                                helperName,
+                                "helper",
+                                Date.now() - startTime,
+                                executionId,
+                                [inputs],
+                                undefined,
+                                error,
+                                controllerExecutionId,
+                                parentExecutionId
+                            )
+                        );
+
+                        throw error;
+                    }
+                };
+            } else {
+
+            }
+        } else {
+
+        }
+
+        return wrappedHelper || helper;
+
+    } catch (err) {
+        logger.errorWithStack(`Error wrapping helper ${helperName}`, err);
+
+        return helper;
+    }
+}
+
+module.exports = wrapHelper;

package/src/utils/executionContext.js

@@ -0,0 +1,42 @@
+
+const { AsyncLocalStorage } = require("async_hooks");
+
+class ExecutionContext {
+
+    constructor() {
+        this.storage = new AsyncLocalStorage();
+    }
+
+    runAsController(controllerExecutionId, fn) {
+        return this.storage.run({
+            controllerExecutionId,
+            currentExecutionId: controllerExecutionId
+        }, fn);
+    }
+
+    runAsExecution(executionId, controllerExecutionId, fn) {
+        return this.storage.run({
+            controllerExecutionId,
+            currentExecutionId: executionId
+        }, fn);
+    }
+
+    getControllerExecutionId() {
+        let store = null;
+
+        store = this.storage.getStore();
+
+        return store ? store.controllerExecutionId : null;
+    }
+
+    getCurrentExecutionId() {
+        let store = null;
+
+        store = this.storage.getStore();
+
+        return store ? store.currentExecutionId : null;
+    }
+
+}
+
+module.exports = new ExecutionContext();

package/src/utils/logger.js

@@ -0,0 +1,150 @@
+
+let instance = null;
+
+class Logger {
+
+    constructor(config) {
+        config = config || {};
+
+        this.enabled = config.enabled !== false;
+        this.level = config.level || "info";
+        this.prefix = "[CodeAura Agent]";
+        this.levels = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3
+        };
+    }
+
+    shouldLog(level) {
+        const currentLevelPriority = this.levels[this.level] || 1,
+            messageLevelPriority = this.levels[level] || 1;
+
+        if (!this.enabled) {
+            return false;
+        } else {
+
+        }
+
+        return messageLevelPriority >= currentLevelPriority;
+    }
+
+    format(level, message, args) {
+        const timestamp = new Date().toISOString(),
+            levelStr = level.toUpperCase().padEnd(5),
+            formattedArgs = [`${this.prefix} [${timestamp}] ${levelStr}:`, message];
+
+        if (args && args.length > 0) {
+            return formattedArgs.concat(args);
+        } else {
+            return formattedArgs;
+        }
+    }
+
+    debug(message, ...args) {
+        const shouldLog = this.shouldLog("debug");
+
+        let formattedArgs = null;
+
+        if (shouldLog) {
+            formattedArgs = this.format("debug", message, args);
+
+            console.log(...formattedArgs);
+        } else {
+
+        }
+    }
+
+    info(message, ...args) {
+        const shouldLog = this.shouldLog("info");
+
+        let formattedArgs = null;
+
+        if (shouldLog) {
+            formattedArgs = this.format("info", message, args);
+
+            console.log(...formattedArgs);
+        } else {
+
+        }
+    }
+
+    warn(message, ...args) {
+        const shouldLog = this.shouldLog("warn");
+
+        let formattedArgs = null;
+
+        if (shouldLog) {
+            formattedArgs = this.format("warn", message, args);
+
+            console.warn(...formattedArgs);
+        } else {
+
+        }
+    }
+
+    error(message, ...args) {
+        const shouldLog = this.shouldLog("error");
+
+        let formattedArgs = null;
+
+        if (shouldLog) {
+            formattedArgs = this.format("error", message, args);
+
+            console.error(...formattedArgs);
+        } else {
+
+        }
+    }
+
+    errorWithStack(message, error) {
+        const shouldLog = this.shouldLog("error");
+
+        if (shouldLog) {
+            this.error(message);
+
+            if (error && error.stack) {
+                console.error(error.stack);
+            } else {
+
+            }
+        } else {
+
+        }
+    }
+
+    configure(config) {
+        if (config.enabled !== undefined) {
+            this.enabled = config.enabled;
+        } else {
+
+        }
+
+        if (config.level !== undefined) {
+            this.level = config.level;
+        } else {
+
+        }
+    }
+
+}
+
+const getLogger = (config) => {
+        if (!instance) {
+            instance = new Logger(config);
+        } else {
+
+        }
+
+        return instance;
+    },
+
+    createLogger = (config) => {
+        return new Logger(config);
+    };
+
+module.exports = {
+    getLogger,
+    createLogger
+};

package/src/utils/publicApiClient.js

@@ -0,0 +1,87 @@
+
+const axios = require("axios");
+
+module.exports = async (action, method, data, config) => {
+    const appUrl = config.apiUrl || "",
+        apiKey = config.apiKey || "",
+        requestMethod = (method || "POST").toUpperCase();
+
+    let options = null,
+        response = null;
+
+    options = {
+        method: requestMethod,
+        url: appUrl + action,
+        headers: {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "apiKey": apiKey
+        },
+        data: data,
+        timeout: config.timeout || 10000,
+        validateStatus: status => status >= 200 && status < 600
+    };
+
+    try {
+        response = await axios(options);
+
+        if (response.status >= 200 && response.status < 300) {
+            if (response.data && response.data.data) {
+                return {
+                    data: response.data.data,
+                    error: null
+                };
+            } else if (response.data) {
+                return {
+                    data: response.data,
+                    error: null
+                };
+            } else {
+                return {
+                    data: null,
+                    error: "Unexpected response format"
+                };
+            }
+        } else if (response.data && response.data.errors && response.data.errors[0]) {
+            return {
+                data: null,
+                error: response.data.errors[0].message || response.data.errors[0]
+            };
+        } else if (response.data && response.data.error) {
+            return {
+                data: null,
+                error: response.data.error
+            };
+        } else {
+            console.error("[CodeAura Agent] Unexpected response body for status " + response.status + ":", JSON.stringify(response.data));
+
+            return {
+                data: null,
+                error: `HTTP ${response.status} error`
+            };
+        }
+    } catch (error) {
+        let errorMessage = "Unknown error";
+
+        if (error.response && error.response.data) {
+            if (error.response.data.errors && error.response.data.errors[0]) {
+                errorMessage = error.response.data.errors[0].message || error.response.data.errors[0];
+            } else if (error.response.data.error) {
+                errorMessage = error.response.data.error;
+            } else {
+                errorMessage = `HTTP ${error.response.status} error`;
+            }
+        } else if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
+            errorMessage = `Request timeout after ${config.timeout || 10000}ms`;
+        } else if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+            errorMessage = `Cannot connect to API: ${error.code}`;
+        } else if (error.message) {
+            errorMessage = error.message;
+        }
+
+        return {
+            data: null,
+            error: errorMessage
+        };
+    }
+};