codeaura-embedded-runtime-agent 0.1.0

package/src/core/transport/httpTransport.js

@@ -0,0 +1,242 @@
+
+const publicApiClient = require("../../utils/publicApiClient");
+
+class HttpTransport {
+
+    constructor(config, agentConfig, logger) {
+        this.config = config || {};
+        this.agentConfig = agentConfig || {};
+        this.logger = logger;
+
+        this.endpoint = this.agentConfig.endpoint;
+        this.apiKey = this.agentConfig.apiKey || "";
+        this.agentVersion = this.agentConfig.version || "0.1.0";
+        this.projectId = this.agentConfig.projectId || null;
+
+        this.timeout = this.config.timeout || 5000;
+        this.retries = this.config.retries || 0;
+
+        this.parseEndpoint();
+        this.validateConfiguration();
+    }
+
+    parseEndpoint() {
+        let url = null,
+            match = null;
+
+        try {
+            url = new URL(this.endpoint);
+            this.apiUrl = `${url.protocol}//${url.host}`;
+            this.action = url.pathname;
+        } catch {
+            match = this.endpoint.match(/^(https?:\/\/[^\/]+)(\/.*)?$/);
+
+            if (match) {
+                this.apiUrl = match[1];
+                this.action = match[2] || "/";
+            } else {
+                this.apiUrl = "";
+                this.action = this.endpoint;
+            }
+        }
+    }
+
+    validateConfiguration() {
+        if (!this.endpoint || typeof this.endpoint !== "string" || this.endpoint.trim() === "") {
+            throw new Error("HTTP Transport: endpoint is required and must be a non-empty string");
+        }
+        if (!this.logger) {
+            throw new Error("HTTP Transport: logger is required");
+        }
+        if (typeof this.timeout !== "number" || !isFinite(this.timeout) || this.timeout <= 0) {
+            throw new Error("HTTP Transport: timeout must be a number > 0");
+        }
+        if (typeof this.retries !== "number" || !isFinite(this.retries) || this.retries < 0) {
+            throw new Error("HTTP Transport: retries must be a number >= 0");
+        }
+    }
+
+    async send(events) {
+        let eventCount = 0,
+            result = null;
+
+        if (events && events.length > 0) {
+            eventCount = events.length;
+
+            this.logger.debug(`Sending ${eventCount} event(s) to ${this.endpoint}`);
+            this.logger.debug("Transport project_id: " + (this.projectId || "none"));
+
+            try {
+                result = await this.executeRequestWithRetries(events, eventCount, "send");
+
+                this.logger.info(`Successfully sent ${eventCount} event(s)`);
+
+                return result;
+            } catch (error) {
+                if (error.response) {
+                    this.logger.errorWithStack(
+                `HTTP error ${error.response.status}: ${JSON.stringify(error.response.data || error.response.body, null, 2)}`,
+                error
+                    );
+                } else {
+                    this.logger.errorWithStack("Error sending events", error);
+                }
+
+                throw error;
+            }
+        }
+    }
+
+    async test() {
+        const testEvent = {
+            type: "test",
+            name: "connection-test",
+            timestamp: new Date().toISOString(),
+            framework: "nodejs",
+            language: "nodejs",
+            durationMs: 0,
+            meta: { test: true }
+        };
+
+        this.logger.info(`Testing connection to ${this.endpoint}`);
+
+        try {
+            await this.executeRequestWithRetries([testEvent], 1, "test");
+
+            this.logger.info("Connection test successful");
+
+            return true;
+        } catch (error) {
+            this.logger.errorWithStack("Connection test failed", error);
+
+            throw error;
+        }
+    }
+
+    async executeRequestWithRetries(events, eventCount, operationType) {
+        let lastError = null,
+            shouldRetry = null;
+
+        const maxAttempts = this.retries + 1,
+            requestData = {
+                events,
+                timestamp: new Date().toISOString(),
+                agent_version: this.agentVersion,
+                project_id: this.projectId
+            },
+
+            apiConfig = {
+                apiUrl: this.apiUrl,
+                apiKey: this.apiKey,
+                timeout: this.timeout
+            };
+
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                if (attempt > 0) {
+                    this.logger.debug(
+                    `Retry attempt ${attempt}/${this.retries} for ${operationType}`
+                    );
+                }
+
+                const result = await publicApiClient(
+                this.action,
+                "POST",
+                requestData,
+                apiConfig
+                );
+
+                if (result?.error) {
+                    throw new Error(
+                    typeof result.error === "string"
+                        ? result.error
+                        : JSON.stringify(result.error)
+                    );
+                }
+
+                this.logger.debug("Request successful");
+
+                return result;
+
+            } catch (error) {
+                const safeError =
+                error instanceof Error
+                    ? error
+                    : new Error(JSON.stringify(error));
+
+                lastError = safeError;
+
+                shouldRetry = this.shouldRetryError(
+                safeError,
+                attempt,
+                maxAttempts
+                );
+
+                if (shouldRetry) {
+                    this.logRetryableError(safeError, eventCount, attempt);
+                    await this.delay(this.calculateBackoff(attempt));
+                } else {
+                    this.logFinalError(safeError, eventCount, operationType);
+
+                    throw safeError;
+                }
+            }
+        }
+
+        this.logFinalError(lastError, eventCount, operationType);
+
+        throw lastError;
+    }
+
+    shouldRetryError(error, attempt, maxAttempts) {
+        const errorMessage = error.message || "",
+            isNetworkError = error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || errorMessage.includes("Cannot connect"),
+            isTimeout = error.code === "ECONNABORTED" || error.code === "ETIMEDOUT" || errorMessage.includes("timeout"),
+            isServerError = errorMessage.includes("HTTP 5"),
+            isClientError = errorMessage.includes("HTTP 4"),
+            hasRetriesLeft = attempt < maxAttempts - 1;
+
+        if (!hasRetriesLeft || isClientError) {
+            return false;
+        }
+
+        return isNetworkError || isTimeout || isServerError;
+    }
+
+    logRetryableError(error, eventCount, attempt) {
+        const errorMessage = error.message || "Unknown error";
+
+        this.logger.warn(`Attempt ${attempt + 1} failed for ${eventCount} event(s): ${errorMessage}`);
+    }
+
+    logFinalError(error, eventCount, operationType) {
+        if (!error) {
+            this.logger.error(`Failed to ${operationType} ${eventCount} event(s): Unknown error`);
+
+            return;
+        }
+
+        const errorMessage = error.message || "Unknown error",
+            fullError = JSON.stringify(error, Object.getOwnPropertyNames(error), 2);
+
+        this.logger.error(`Failed to ${operationType} ${eventCount} event(s): ${errorMessage}`);
+        this.logger.debug(`Full error details: ${fullError}`);
+
+        if (error.stack) {
+            this.logger.error(error.stack);
+        }
+    }
+
+    calculateBackoff(attempt) {
+        const baseDelay = 1000;
+
+        return Math.min(baseDelay * Math.pow(2, attempt), 10000);
+    }
+
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+}
+
+module.exports = HttpTransport;

package/src/framework/nodejs/sails/SailsAdapter.js

@@ -0,0 +1,83 @@
+
+let SailsHook = require("./sailsHook");
+
+class SailsAdapter {
+
+    constructor(frameworkConfig, agent) {
+        this.frameworkConfig = null;
+        this.agent = null;
+        this.logger = null;
+        this.sailsInstance = null;
+        this.sailsHook = null;
+        this.initialized = false;
+
+        this.frameworkConfig = frameworkConfig || {};
+        this.agent = agent;
+        this.logger = agent.getLogger();
+
+        this.validateFrameworkConfig();
+    }
+
+    validateFrameworkConfig() {
+        if (!this.frameworkConfig.instance) {
+            throw new Error("SailsAdapter: framework instance is required");
+        } else {
+
+        }
+
+        this.sailsInstance = this.frameworkConfig.instance;
+    }
+
+    init() {
+        try {
+            this.logger.info("Initializing Sails.js adapter");
+
+            if (!this.sailsInstance) {
+                throw new Error("Sails instance is required");
+            } else {
+
+            }
+
+            this.sailsHook = new SailsHook(this.sailsInstance, this.agent);
+
+            this.initialized = true;
+            this.logger.info("Sails.js adapter initialized successfully");
+        } catch (error) {
+            this.logger.errorWithStack("Failed to initialize Sails adapter", error);
+
+            throw error;
+        }
+    }
+
+    isInitialized() {
+        return this.initialized;
+    }
+
+    getInstrumentationStatus() {
+        let status = null;
+
+        if (this.sailsHook) {
+            status = this.sailsHook.getInstrumentationStatus();
+        } else {
+            status = {
+                controllersInstrumented: false,
+                helpersInstrumented: false
+            };
+        }
+
+        return status;
+    }
+
+    verifyInstrumentation() {
+        if (this.sailsHook) {
+            return this.sailsHook.verifyInstrumentation();
+        } else {
+
+        }
+
+        return null;
+    }
+
+}
+
+module.exports = SailsAdapter;

package/src/framework/nodejs/sails/sailsHook.js

@@ -0,0 +1,248 @@
+
+let wrappers = require("../../../instrumentation/nodejs/wrappers"),
+    instrumentHelperTree = require("../../../instrumentation/nodejs/instrumentHelperTree");
+
+class SailsHook {
+
+    constructor(sailsInstance, agent) {
+        this.sails = null;
+        this.agent = null;
+        this.logger = null;
+        this.buffer = null;
+        this.config = null;
+        this.controllersInstrumented = false;
+        this.helpersInstrumented = false;
+
+        this.sails = sailsInstance;
+        this.agent = agent;
+        this.logger = agent.getLogger();
+        this.buffer = agent.buffer;
+        this.config = agent.getConfig();
+
+        this.initialize();
+    }
+
+    initialize() {
+        let self = null;
+
+        self = this;
+
+        try {
+            this.logger.debug("Initializing Sails hook");
+
+            if (!this.sails) {
+                throw new Error("Sails instance is required");
+            } else {
+
+            }
+
+            if (this.sails._exited === false) {
+                this.logger.info("Sails is already lifted, instrumenting immediately");
+                this.onSailsLifted();
+            } else {
+                this.logger.debug("Sails not yet lifted, listening for lifted event");
+                this.sails.on("lifted", () => {
+                    self.onSailsLifted();
+                });
+            }
+
+            this.logger.debug("Sails hook initialization complete");
+        } catch (error) {
+            this.logger.errorWithStack("Error initializing Sails hook", error);
+
+            throw error;
+        }
+    }
+
+    onSailsLifted() {
+        let self = null;
+
+        self = this;
+
+        try {
+            this.logger.info("========== SAILS LIFTED - STARTING INSTRUMENTATION ==========");
+
+            this.instrumentControllers();
+            this.instrumentHelpers();
+
+            this.logger.info("========== INSTRUMENTATION COMPLETE ==========");
+
+            setTimeout(() => {
+                self.verifyInstrumentation();
+            }, 5000);
+        } catch (error) {
+            this.logger.errorWithStack("Error during Sails lifted event", error);
+        }
+    }
+
+    instrumentControllers() {
+        try {
+            const shouldInstrument = this.config.get("instrumentation").controllers;
+
+            let actions = null,
+                actionNames = null,
+                instrumentedCount = 0,
+                immediateCheck = null,
+                immediateSymbols = null,
+                immediateWrapped = false;
+
+            if (!shouldInstrument) {
+                this.logger.info("Controller instrumentation is disabled");
+
+                return;
+            }
+
+            actions = this.sails._actions || {};
+            actionNames = Object.keys(actions);
+
+            this.logger.info(`>>> Found ${actionNames.length} controller actions to instrument`);
+
+            for (const actionName of actionNames) {
+                const action = actions[actionName];
+
+                let targetFunction = null,
+                    wrappedFunction = null;
+
+                if (typeof action === "function") {
+                    targetFunction = action;
+                } else if (typeof action === "object" && action !== null && typeof action.fn === "function") {
+                    targetFunction = action.fn;
+                } else {
+                    continue;
+                }
+
+                wrappedFunction = wrappers.wrapFunction(
+                    targetFunction,
+                    actionName,
+                    "controller",
+                    this.buffer,
+                    this.logger
+                );
+
+                if (typeof action === "function") {
+                    this.sails._actions[actionName] = wrappedFunction;
+                } else {
+                    action.fn = wrappedFunction;
+                }
+
+                instrumentedCount++;
+            }
+
+            this.controllersInstrumented = true;
+            this.logger.info(`>>> Successfully instrumented ${instrumentedCount} controller actions`);
+
+            immediateCheck = this.sails._actions[actionNames[0]];
+
+            if (immediateCheck && typeof immediateCheck === "function") {
+                immediateSymbols = Object.getOwnPropertySymbols(immediateCheck);
+                immediateWrapped = immediateSymbols.some(sym => sym.toString().includes("__codeaura_wrapped__"));
+
+                this.logger.info(`>>> Immediate verification - first action wrapped: ${immediateWrapped}`);
+            } else {
+
+            }
+        } catch (error) {
+            this.logger.errorWithStack("Error instrumenting controllers", error);
+        }
+    }
+
+    instrumentHelpers() {
+        try {
+            const shouldInstrument = this.config.get("instrumentation").helpers,
+                helpers = this.sails.helpers || {};
+
+            if (!shouldInstrument) {
+                this.logger.info("Helper instrumentation is disabled");
+
+                return;
+            }
+
+            this.logger.info(`>>> Found ${Object.keys(helpers).length} top-level helpers to instrument`);
+
+            instrumentHelperTree(helpers, "", this.buffer, this.logger);
+
+            this.helpersInstrumented = true;
+            this.logger.info(">>> All helpers instrumented successfully");
+        } catch (error) {
+            this.logger.errorWithStack("Error instrumenting helpers", error);
+        }
+    }
+
+    getInstrumentationStatus() {
+        let status = null;
+
+        status = {
+            controllersInstrumented: this.controllersInstrumented,
+            helpersInstrumented: this.helpersInstrumented
+        };
+
+        return status;
+    }
+
+    verifyInstrumentation() {
+        let actions = null,
+            actionNames = null,
+            wrappedCount = 0,
+            unwrappedCount = 0,
+            actionName = null,
+            action = null,
+            i = 0,
+            symbols = null,
+            hasWrappedSymbol = false,
+            callStats = null;
+
+        try {
+            actions = this.sails._actions || {};
+            actionNames = Object.keys(actions);
+
+            this.logger.info(`Verifying instrumentation for ${actionNames.length} actions`);
+
+            for (i = 0; i < actionNames.length; i++) {
+                actionName = actionNames[i];
+                action = actions[actionName];
+
+                let functionToCheck = null;
+
+                if (typeof action === "function") {
+                    functionToCheck = action;
+                } else if (typeof action === "object" && action !== null && typeof action.fn === "function") {
+                    functionToCheck = action.fn;
+                } else {
+                    this.logger.debug(`Skipping verification for ${actionName} - not a function or object with fn`);
+                    continue;
+                }
+
+                symbols = Object.getOwnPropertySymbols(functionToCheck);
+                hasWrappedSymbol = symbols.some(sym => sym.toString().includes("__codeaura_wrapped__"));
+
+                if (hasWrappedSymbol) {
+                    wrappedCount++;
+                    this.logger.debug(`Action ${actionName} is wrapped (type: ${typeof action})`);
+                } else {
+                    unwrappedCount++;
+                    this.logger.warn(`Action ${actionName} is NOT wrapped (type: ${typeof action})`);
+                }
+            }
+
+            this.logger.info(`Verification complete: ${wrappedCount} wrapped, ${unwrappedCount} unwrapped`);
+
+            callStats = wrappers.getCallStatistics();
+
+            this.logger.info(`Call statistics: ${JSON.stringify(callStats, null, 2)}`);
+
+            return {
+                total: actionNames.length,
+                wrapped: wrappedCount,
+                unwrapped: unwrappedCount,
+                callStats: callStats
+            };
+        } catch (error) {
+            this.logger.errorWithStack("Error verifying instrumentation", error);
+
+            return null;
+        }
+    }
+
+}
+
+module.exports = SailsHook;

package/src/instrumentation/nodejs/instrumentHelperTree.js

@@ -0,0 +1,31 @@
+
+const { wrapHelper } = require("./wrappers");
+
+function instrumentHelperTree(node, path, buffer, logger) {
+    let key = null,
+        fullPath = null,
+        item = null;
+
+    if (node && typeof node === "object") {
+        for (key in node) {
+            if (Object.prototype.hasOwnProperty.call(node, key)) {
+                fullPath = path ? `${path}/${key}` : key;
+                item = node[key];
+
+                if (typeof item === "function") {
+                    node[key] = wrapHelper(item, fullPath, buffer, logger);
+                } else if (typeof item === "object" && item !== null) {
+                    instrumentHelperTree(item, fullPath, buffer, logger);
+                } else {
+
+                }
+            } else {
+
+            }
+        }
+    } else {
+
+    }
+}
+
+module.exports = instrumentHelperTree;