codeaura-embedded-runtime-agent 0.1.0

package/src/config/config.js

@@ -0,0 +1,261 @@
+
+const DEFAULT_ENDPOINT = "https://public-api.codeaura.ai/api/v1/runtime-agent/events",
+    defaultConfig = {
+        enabled: true,
+        endpoint: DEFAULT_ENDPOINT,
+        apiKey: process.env.API_KEY,
+        projectId: null,
+        framework: null,
+        buffer: {
+            maxSize: 100,
+            flushInterval: 5000,
+            maxRetrySize: 500
+        },
+        transport: {
+            timeout: 5000,
+            retries: 0
+        },
+        instrumentation: {
+            controllers: true,
+            helpers: true
+        },
+        logging: {
+            enabled: true,
+            level: "info"
+        }
+    },
+
+    VALID_LOG_LEVELS = ["debug", "info", "warn", "error"];
+
+class Config {
+
+    constructor(userConfig) {
+        this.config = null;
+
+        userConfig = userConfig || {};
+
+        try {
+            this.config = this.mergeDeep(defaultConfig, userConfig);
+            this.validate();
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    mergeDeep(defaults, userConfig) {
+        let merged = {},
+            key = null,
+            defaultValue = null,
+            userValue = null,
+            isDefaultObject = false,
+            isUserObject = false;
+
+        for (key in defaults) {
+            if (Object.prototype.hasOwnProperty.call(defaults, key)) {
+                defaultValue = defaults[key];
+                userValue = userConfig[key];
+                isDefaultObject = defaultValue !== null && typeof defaultValue === "object" && !Array.isArray(defaultValue);
+                isUserObject = userValue !== null && typeof userValue === "object" && !Array.isArray(userValue);
+
+                if (isDefaultObject && isUserObject) {
+                    merged[key] = this.mergeDeep(defaultValue, userValue);
+                } else if (userValue !== undefined && userValue !== null) {
+                    merged[key] = userValue;
+                } else if (userValue === null && key === "framework") {
+                    merged[key] = null;
+                } else {
+                    merged[key] = defaultValue;
+                }
+            } else {
+
+            }
+        }
+
+        return merged;
+    }
+
+    validate() {
+        let frameworkType = null,
+            logLevel = null;
+
+        try {
+            if (!this.config.apiKey || typeof this.config.apiKey !== "string") {
+                throw new Error("[CodeAura Agent] Configuration error: apiKey is required and must be a string");
+            } else {
+
+            }
+
+            if (this.config.framework !== null && typeof this.config.framework !== "object") {
+                throw new Error("[CodeAura Agent] Configuration error: framework must be null or an object");
+            } else {
+
+            }
+
+            if (this.config.framework !== null) {
+                frameworkType = this.config.framework.type;
+
+                if (frameworkType !== null && typeof frameworkType !== "string") {
+                    throw new Error("[CodeAura Agent] Configuration error: framework.type must be null or a string");
+                } else {
+
+                }
+            } else {
+
+            }
+
+            this.validateBuffer();
+            this.validateTransport();
+            this.validateInstrumentation();
+
+            if (typeof this.config.logging.enabled !== "boolean") {
+                throw new Error("[CodeAura Agent] Configuration error: logging.enabled must be a boolean");
+            } else {
+
+            }
+
+            logLevel = this.config.logging.level;
+
+            if (VALID_LOG_LEVELS.indexOf(logLevel) === -1) {
+                throw new Error("[CodeAura Agent] Configuration error: logging.level must be one of: " + VALID_LOG_LEVELS.join(", "));
+            } else {
+
+            }
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    validateBuffer() {
+        let maxSize = null,
+            flushInterval = null;
+
+        maxSize = this.config.buffer.maxSize;
+        flushInterval = this.config.buffer.flushInterval;
+
+        if (typeof maxSize !== "number" || !isFinite(maxSize) || maxSize < 1) {
+            throw new Error("[CodeAura Agent] Configuration error: buffer.maxSize must be a number >= 1");
+        } else {
+
+        }
+
+        if (typeof flushInterval !== "number" || !isFinite(flushInterval) || flushInterval < 100) {
+            throw new Error("[CodeAura Agent] Configuration error: buffer.flushInterval must be a number >= 100ms");
+        } else {
+
+        }
+
+        let maxRetrySize = null;
+
+        maxRetrySize = this.config.buffer.maxRetrySize;
+
+        if (typeof maxRetrySize !== "number" || !isFinite(maxRetrySize) || maxRetrySize < 1) {
+            throw new Error("[CodeAura Agent] Configuration error: buffer.maxRetrySize must be a number >= 1");
+        } else {
+
+        }
+    }
+
+    validateTransport() {
+        let timeout = null,
+            retries = null;
+
+        timeout = this.config.transport.timeout;
+        retries = this.config.transport.retries;
+
+        if (typeof timeout !== "number" || !isFinite(timeout) || timeout <= 0) {
+            throw new Error("[CodeAura Agent] Configuration error: transport.timeout must be a number > 0");
+        } else {
+
+        }
+
+        if (typeof retries !== "number" || !isFinite(retries) || retries < 0) {
+            throw new Error("[CodeAura Agent] Configuration error: transport.retries must be a number >= 0");
+        } else {
+
+        }
+    }
+
+    validateInstrumentation() {
+        let controllers = null,
+            helpers = null;
+
+        controllers = this.config.instrumentation.controllers;
+        helpers = this.config.instrumentation.helpers;
+
+        if (typeof controllers !== "boolean") {
+            throw new Error("[CodeAura Agent] Configuration error: instrumentation.controllers must be a boolean");
+        } else {
+
+        }
+
+        if (typeof helpers !== "boolean") {
+            throw new Error("[CodeAura Agent] Configuration error: instrumentation.helpers must be a boolean");
+        } else {
+
+        }
+    }
+
+    get(key) {
+        return this.config[key];
+    }
+
+    isEnabled() {
+        return this.config.enabled === true;
+    }
+
+    getAll() {
+        let configCopy = null;
+
+        configCopy = this.deepCopy(this.config);
+
+        return configCopy;
+    }
+
+    deepCopy(obj, seen = new WeakSet()) {
+        let copy = null,
+            key = null,
+            value = null,
+            isObject = false;
+
+        if (obj === null || typeof obj !== "object") {
+            return obj;
+        } else {
+
+        }
+
+        if (seen.has(obj)) {
+            return undefined;
+        }
+
+        if (Array.isArray(obj)) {
+            seen.add(obj);
+
+            return obj.map(item => this.deepCopy(item, seen));
+        } else {
+
+        }
+
+        copy = {};
+        seen.add(obj);
+
+        for (key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                value = obj[key];
+                isObject = value !== null && typeof value === "object" && !Array.isArray(value);
+
+                if (isObject) {
+                    copy[key] = this.deepCopy(value, seen);
+                } else {
+                    copy[key] = value;
+                }
+            } else {
+
+            }
+        }
+
+        return copy;
+    }
+
+}
+
+module.exports = Config;

package/src/core/buffer/memoryBuffer.js

@@ -0,0 +1,164 @@
+
+class MemoryBuffer {
+
+    constructor(config, transport, logger, agentConfig) {
+        this.config = config || {};
+        this.transport = transport;
+        this.logger = logger;
+        this.agentConfig = agentConfig || {};
+        this.projectId = this.agentConfig.projectId || null;
+        this.buffer = [];
+        this.retryBuffer = [];
+        this.maxSize = this.config.maxSize || 100;
+        this.maxRetrySize = this.config.maxRetrySize || 500;
+        this.flushInterval = this.config.flushInterval || 5000;
+        this.flushTimer = null;
+        this.flushing = false;
+
+        this.startFlushTimer();
+    }
+
+    add(event) {
+        try {
+            if (event) {
+                if (this.projectId) {
+                    event.projectId = this.projectId;
+                }
+
+                this.buffer.push(event);
+                this.logger.debug(`Event added to buffer. Current size: ${this.buffer.length}`);
+
+                if (this.buffer.length >= this.maxSize) {
+                    this.flush();
+                }
+            }
+        } catch (error) {
+            this.logger.errorWithStack("Error adding event to buffer", error);
+        }
+    }
+
+    moveToRetryBuffer(events) {
+        let available = 0,
+            eventsToRetry = null,
+            dropped = 0;
+
+        try {
+            available = this.maxRetrySize - this.retryBuffer.length;
+
+            if (available <= 0) {
+                this.logger.warn(`Retry buffer full (${this.maxRetrySize}). Discarding ${events.length} event(s).`);
+            } else if (events.length > available) {
+                dropped = events.length - available;
+                eventsToRetry = events.slice(0, available);
+                this.retryBuffer = this.retryBuffer.concat(eventsToRetry);
+                this.logger.warn(`Retry buffer nearly full. Discarding ${dropped} event(s). Retry buffer size: ${this.retryBuffer.length}`);
+            } else {
+                eventsToRetry = events;
+                this.retryBuffer = this.retryBuffer.concat(eventsToRetry);
+                this.logger.debug(`Moved ${eventsToRetry.length} event(s) to retry buffer. Retry buffer size: ${this.retryBuffer.length}`);
+            }
+        } catch (error) {
+            this.logger.errorWithStack("Error moving events to retry buffer", error);
+        }
+    }
+
+    async flush() {
+        if (this.flushing) {
+            this.logger.debug("Flush already in progress, skipping");
+
+            return;
+        }
+
+        if (this.buffer.length === 0 && this.retryBuffer.length === 0) {
+            this.logger.debug("Buffer is empty, skipping flush");
+
+            return;
+        }
+
+        this.flushing = true;
+
+        let eventsToSend = null,
+            currentEvents = null,
+            retryEvents = null,
+            eventCount = 0;
+
+        try {
+            retryEvents = this.retryBuffer.slice();
+            currentEvents = this.buffer.slice();
+            eventsToSend = retryEvents.concat(currentEvents);
+            eventCount = eventsToSend.length;
+
+            this.buffer = [];
+            this.retryBuffer = [];
+
+            this.logger.debug(`Flushing ${eventCount} event(s) (${retryEvents.length} retry, ${currentEvents.length} new)`);
+
+            if (this.transport) {
+                try {
+                    await this.transport.send(eventsToSend);
+                } catch (transportError) {
+                    this.logger.errorWithStack(`Transport error while sending ${eventCount} event(s)`, transportError);
+                    this.moveToRetryBuffer(eventsToSend);
+                }
+            } else {
+                this.logger.warn(`No transport available, discarding ${eventCount} event(s)`);
+            }
+        } catch (error) {
+            this.logger.errorWithStack("Error flushing buffer", error);
+        } finally {
+            this.flushing = false;
+        }
+    }
+
+    startFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+
+        this.flushTimer = setInterval(() => {
+            this.flush();
+        }, this.flushInterval);
+
+        this.logger.debug(`Flush timer started with interval: ${this.flushInterval}ms`);
+    }
+
+    stopFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+            this.logger.debug("Flush timer stopped");
+        }
+    }
+
+    getSize() {
+        return this.buffer.length;
+    }
+
+    getRetrySize() {
+        return this.retryBuffer.length;
+    }
+
+    clear() {
+        const previousSize = this.buffer.length,
+            previousRetrySize = this.retryBuffer.length;
+
+        this.buffer = [];
+        this.retryBuffer = [];
+        this.logger.debug(`Buffer cleared. Discarded ${previousSize} event(s) and ${previousRetrySize} retry event(s).`);
+    }
+
+    async shutdown() {
+        try {
+            this.logger.debug("Shutting down memory buffer");
+
+            this.stopFlushTimer();
+            await this.flush();
+
+            this.logger.debug("Memory buffer shutdown complete");
+        } catch (error) {
+            this.logger.errorWithStack("Error during buffer shutdown", error);
+        }
+    }
+}
+
+module.exports = MemoryBuffer;

package/src/core/events/EventSchema.js

@@ -0,0 +1,171 @@
+
+class EventSchema {
+
+    static create(params) {
+        let type = null,
+            name = null,
+            durationMs = null,
+            meta = null,
+            error = null,
+            event = null,
+            inputs = null,
+            output = null,
+            path = "",
+            errorInfo = null;
+
+        type = params.type;
+        name = params.name;
+        durationMs = params.durationMs;
+        meta = params.meta || {};
+        inputs = params.inputs || null;
+        output = params.output || null;
+        error = params.error || null;
+        path = params.path || "";
+
+        event = {
+            id: EventSchema.generateId(),
+            timestamp: new Date().toISOString(),
+            type: type,
+            name: name,
+            framework: "sailsjs",
+            language: "nodejs",
+            durationMs: Math.round(durationMs * 100) / 100,
+            controllerExecutionId: params.controllerExecutionId || null,
+            parentExecutionId: params.parentExecutionId || null,
+            meta: meta,
+            inputs: inputs,
+            output: output,
+            path: path
+        };
+
+        if (error) {
+            errorInfo = {
+                message: error.message,
+                type: error.name || "Error",
+                stack: error.stack
+            };
+            event.error = errorInfo;
+        } else {
+
+        }
+
+        return event;
+    }
+
+    static createControllerEvent(params) {
+        let name = null,
+            durationMs = null,
+            meta = null,
+            error = null,
+            inputs = null,
+            output = null,
+            path = "",
+            event = null;
+
+        name = params.name;
+        durationMs = params.durationMs;
+        meta = params.meta || {};
+        error = params.error || null;
+        inputs = params.inputs || null;
+        output = params.output || null;
+        path = params.path || "";
+
+        event = EventSchema.create({
+            type: "controller",
+            name: name,
+            durationMs: durationMs,
+            meta: meta,
+            inputs: inputs,
+            output: output,
+            path: path,
+            error: error
+        });
+
+        return event;
+    }
+
+    static createHelperEvent(params) {
+        let name = null,
+            durationMs = null,
+            meta = null,
+            error = null,
+            inputs = null,
+            output = null,
+            path = "",
+            event = null;
+
+        name = params.name;
+        durationMs = params.durationMs;
+        meta = params.meta || {};
+        error = params.error || null;
+        inputs = params.inputs || null;
+        output = params.output || null;
+        path = params.path || "";
+
+        event = EventSchema.create({
+            type: "helper",
+            name: name,
+            durationMs: durationMs,
+            meta: meta,
+            inputs: inputs,
+            output: output,
+            path: path,
+            error: error,
+            controllerExecutionId: params.controllerExecutionId || null,
+            parentExecutionId: params.parentExecutionId || null
+        });
+
+        return event;
+    }
+
+    static validate(event) {
+        let requiredFields = null,
+            i = 0,
+            field = null,
+            isValidType = false,
+            isValidDuration = false;
+
+        requiredFields = ["id", "timestamp", "type", "name", "framework", "language", "durationMs"];
+
+        for (i = 0; i < requiredFields.length; i++) {
+            field = requiredFields[i];
+
+            if (event[field] === undefined || event[field] === null) {
+                return false;
+            } else {
+
+            }
+        }
+
+        isValidType = (event.type === "controller" || event.type === "helper");
+        if (!isValidType) {
+            return false;
+        } else {
+
+        }
+
+        isValidDuration = (typeof event.durationMs === "number" && event.durationMs >= 0);
+        if (!isValidDuration) {
+            return false;
+        } else {
+
+        }
+
+        return true;
+    }
+
+    static generateId() {
+        let timestamp = null,
+            random = null,
+            id = null;
+
+        timestamp = Date.now().toString(36);
+        random = Math.random().toString(36).substring(2, 9);
+        id = timestamp + "-" + random;
+
+        return id;
+    }
+
+}
+
+module.exports = EventSchema;