evergreen-sdk 1.0.0 → 1.0.2

package/dist/index.js

@@ -10,15 +10,35 @@ const traceStorage = new node_async_hooks_1.AsyncLocalStorage();
 let ws = null;
 let isConnected = false;
 const pendingTelemetry = [];
+function getTelemetryWsUrl() {
+    const explicit = process.env.EVERGREEN_TRACE_WS_URL;
+    if (explicit && explicit.trim())
+        return explicit.trim();
+    return "ws://localhost:4321";
+}
+function shouldDebugTelemetryConnection() {
+    return (process.env.EVERGREEN_TRACE_DEBUG === "1" ||
+        process.env.EVERGREEN_TRACE_DEBUG === "true");
+}
 // Connect to the VS Code Extension Hub
 function connect() {
     if (ws &&
         (ws.readyState === ws_1.default.CONNECTING || ws.readyState === ws_1.default.OPEN))
         return;
+    const url = getTelemetryWsUrl();
+    const debug = shouldDebugTelemetryConnection();
     try {
-        ws = new ws_1.default("ws://localhost:3000");
+        if (debug) {
+            // eslint-disable-next-line no-console
+            console.log(`🌲 Evergreen Trace: connecting to ${url}`);
+        }
+        ws = new ws_1.default(url);
         ws.on("open", () => {
             isConnected = true;
+            if (debug) {
+                // eslint-disable-next-line no-console
+                console.log(`🌲 Evergreen Trace: connected to ${url}`);
+            }
             // Flush any telemetry that was emitted before the socket became ready.
             while (pendingTelemetry.length > 0) {
                 const queued = pendingTelemetry.shift();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evergreen-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Evergreen Trace Backend SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,4 +17,4 @@
     "@types/ws": "^8.5.5",
     "typescript": "^5.0.0"
   }
-}
+}

package/src/index.ts

@@ -23,6 +23,19 @@ let ws: WebSocket | null = null;
 let isConnected = false;
 const pendingTelemetry: any[] = [];
 
+function getTelemetryWsUrl(): string {
+  const explicit = process.env.EVERGREEN_TRACE_WS_URL;
+  if (explicit && explicit.trim()) return explicit.trim();
+  return "ws://localhost:4321";
+}
+
+function shouldDebugTelemetryConnection(): boolean {
+  return (
+    process.env.EVERGREEN_TRACE_DEBUG === "1" ||
+    process.env.EVERGREEN_TRACE_DEBUG === "true"
+  );
+}
+
 // Connect to the VS Code Extension Hub
 function connect() {
   if (
@@ -31,11 +44,23 @@ function connect() {
   )
     return;
 
+  const url = getTelemetryWsUrl();
+  const debug = shouldDebugTelemetryConnection();
+
   try {
-    ws = new WebSocket("ws://localhost:4321");
+    if (debug) {
+      // eslint-disable-next-line no-console
+      console.log(`🌲 Evergreen Trace: connecting to ${url}`);
+    }
+
+    ws = new WebSocket(url);
 
     ws.on("open", () => {
       isConnected = true;
+      if (debug) {
+        // eslint-disable-next-line no-console
+        console.log(`🌲 Evergreen Trace: connected to ${url}`);
+      }
       // Flush any telemetry that was emitted before the socket became ready.
       while (pendingTelemetry.length > 0) {
         const queued = pendingTelemetry.shift();

package/src/index.js

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evergreen = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-const ws_1 = require("ws");
-const traceStorage = new node_async_hooks_1.AsyncLocalStorage();
-let ws = null;
-let isConnected = false;
-// Connect to the VS Code Extension Hub
-function connect() {
-    if (ws && (ws.readyState === ws_1.default.CONNECTING || ws.readyState === ws_1.default.OPEN))
-        return;
-    try {
-        ws = new ws_1.default('ws://localhost:3000');
-        ws.on('open', () => {
-            isConnected = true;
-        });
-        ws.on('close', () => {
-            isConnected = false;
-            // Optionally implement reconnect logic here
-        });
-        ws.on('error', () => {
-            isConnected = false;
-            // Silently fail if extension is not running
-        });
-    }
-    catch (error) {
-        isConnected = false;
-    }
-}
-// Ensure connection is attempted
-connect();
-function sanitizePayload(obj, maxDepth = 3) {
-    if (maxDepth <= 0)
-        return '[Max Depth Reached]';
-    if (obj === null || obj === undefined)
-        return obj;
-    if (typeof obj !== 'object')
-        return obj;
-    if (obj instanceof Error) {
-        return { name: obj.name, message: obj.message, stack: obj.stack };
-    }
-    if (Array.isArray(obj)) {
-        return obj.map(item => sanitizePayload(item, maxDepth - 1));
-    }
-    const sanitized = {};
-    for (const [key, value] of Object.entries(obj)) {
-        sanitized[key] = sanitizePayload(value, maxDepth - 1);
-    }
-    return sanitized;
-}
-function sendTelemetry(payload) {
-    if (!isConnected || !ws || ws.readyState !== ws_1.default.OPEN)
-        return;
-    try {
-        ws.send(JSON.stringify(payload));
-    }
-    catch (error) {
-        // Fire and forget, silently ignore send errors
-    }
-}
-function extractLocationFromStack(stack) {
-    if (!stack)
-        return undefined;
-    // The stack will look like:
-    // Error
-    //   at Object.step (/path/to/sdk/index.ts:...)
-    //   at myBusinessLogic (/path/to/business/logic.ts:42:15)
-    const lines = stack.split('\n');
-    if (lines.length >= 3) {
-        const callerLine = lines[2];
-        const match = callerLine.match(/\((.+):(\d+):\d+\)/) || callerLine.match(/at (.+):(\d+):\d+/);
-        if (match && match.length >= 3) {
-            return { file: match[1], line: parseInt(match[2], 10) };
-        }
-    }
-    return undefined;
-}
-exports.evergreen = {
-    clear() {
-        sendTelemetry({ type: 'CLEAR' });
-    },
-    run(jobId, fn) {
-        return traceStorage.run({ jobId }, fn);
-    },
-    async step(name, fn, options) {
-        const store = traceStorage.getStore();
-        // If no context, just execute the function normally without tracing
-        if (!store) {
-            return await fn();
-        }
-        const { jobId, previousStep } = store;
-        // Capture location using a throwaway error
-        const locationError = new Error();
-        const location = extractLocationFromStack(locationError.stack) || { file: 'unknown', line: 0 };
-        const timestamp = Date.now();
-        const startTime = process.hrtime.bigint();
-        // Emit NODE_STARTED
-        sendTelemetry({
-            event: 'NODE_STARTED',
-            status: 'PENDING',
-            jobId,
-            stepName: name,
-            previousStep,
-            location,
-            timestamp
-        });
-        // We must ensure subsequent nested steps know this step is their parent.
-        // To do this, we run the inner function in a nested context.
-        const newContext = { ...store, previousStep: name };
-        try {
-            // Execute the business logic within the new nested context
-            const result = await traceStorage.run(newContext, async () => {
-                return await fn();
-            });
-            const endTime = process.hrtime.bigint();
-            const durationMs = Number(endTime - startTime) / 1000000;
-            // Emit NODE_COMPLETED
-            sendTelemetry({
-                event: 'NODE_COMPLETED',
-                status: 'SUCCESS',
-                jobId,
-                stepName: name,
-                previousStep,
-                payload: { input: sanitizePayload(options?.input), output: sanitizePayload(result) },
-                context: {
-                    input: sanitizePayload(options?.input),
-                    output: sanitizePayload(result),
-                    duration: durationMs
-                },
-                location,
-                timestamp: Date.now()
-            });
-            return result;
-        }
-        catch (error) {
-            const endTime = process.hrtime.bigint();
-            const durationMs = Number(endTime - startTime) / 1000000;
-            // Emit NODE_FAILED
-            sendTelemetry({
-                event: 'NODE_FAILED',
-                status: 'FAILED',
-                jobId,
-                stepName: name,
-                previousStep,
-                payload: { input: sanitizePayload(options?.input), error: sanitizePayload(error) },
-                context: {
-                    input: sanitizePayload(options?.input),
-                    error: sanitizePayload(error),
-                    duration: durationMs
-                },
-                location,
-                timestamp: Date.now()
-            });
-            // Re-throw so backend logic behaves normally
-            throw error;
-        }
-    }
-};
-//# sourceMappingURL=index.js.map