@mynitorai/sdk 0.1.1 → 0.1.4

package/dist/index.d.ts

@@ -4,19 +4,26 @@
  */
 export interface MyNitorConfig {
     apiKey: string;
-    environment?: string;
     endpoint?: string;
 }
 export declare class MyNitor {
     private static instance;
     private config;
     private isInstrumented;
+    private pendingPromises;
     private constructor();
     static init(config: MyNitorConfig): MyNitor;
     /**
      * Automatically detect and wrap AI libraries like OpenAI
      */
     instrument(): void;
+    /**
+     * Waits for all pending network requests to complete.
+     * Call this before your process exits (e.g. in AWS Lambda or scripts).
+     * @param timeoutMs Maximum time to wait in milliseconds (default: 10000)
+     */
+    flush(timeoutMs?: number): Promise<void>;
+    private getCallSite;
     private sendEvent;
     private wrapOpenAI;
 }

package/dist/index.js

@@ -8,9 +8,9 @@ exports.init = exports.MyNitor = void 0;
 class MyNitor {
     constructor(config) {
         this.isInstrumented = false;
+        this.pendingPromises = new Set();
         this.config = {
-            environment: 'production',
-            endpoint: 'https://www.mynitor.ai/api/v1/events',
+            endpoint: 'https://app.mynitor.ai/api/v1/events',
             ...config
         };
     }
@@ -30,10 +30,54 @@ class MyNitor {
         this.isInstrumented = true;
         console.log('🚀 MyNitor: Auto-instrumentation active.');
     }
+    /**
+     * Waits for all pending network requests to complete.
+     * Call this before your process exits (e.g. in AWS Lambda or scripts).
+     * @param timeoutMs Maximum time to wait in milliseconds (default: 10000)
+     */
+    async flush(timeoutMs = 10000) {
+        if (this.pendingPromises.size === 0)
+            return;
+        console.log(`🚀 MyNitor: Flushing ${this.pendingPromises.size} pending logs...`);
+        const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+        const allSettledPromise = Promise.allSettled(this.pendingPromises);
+        await Promise.race([allSettledPromise, timeoutPromise]);
+    }
+    getCallSite() {
+        try {
+            const err = new Error();
+            const stack = err.stack?.split('\n') || [];
+            // Look for the frame that called the LLM method
+            // Stack usually: Error -> getCallSite -> wrapOpenAI wrapper -> USER CODE
+            // We iterate to find the first frame NOT in MyNitor SDK
+            for (const line of stack) {
+                if (!line.includes('mynitor') && !line.includes('Error') && line.includes('/')) {
+                    // Typical format: "    at Object.myFunction (/path/to/file.ts:10:5)"
+                    const match = line.match(/at\s+(?:(.+?)\s+\()?(.*?):(\d+):(\d+)\)?/);
+                    if (match) {
+                        const func = match[1] || 'anonymous';
+                        const fullPath = match[2];
+                        const filename = fullPath.split('/').pop()?.split('.')[0] || 'unknown';
+                        return {
+                            file: fullPath,
+                            line: parseInt(match[3]),
+                            functionName: func,
+                            workflowGuess: `${filename}:${func}`.replace('Object.', '')
+                        };
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // fail safe
+        }
+        return { file: 'unknown', line: 0, functionName: 'unknown', workflowGuess: 'default-workflow' };
+    }
     async sendEvent(payload) {
         try {
-            // Fire and forget - we don't await this to keep the user's app fast
-            fetch(this.config.endpoint, {
+            // Fire and forget
+            // Fire and forget (but track)
+            const promise = fetch(this.config.endpoint, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
@@ -41,20 +85,20 @@ class MyNitor {
                 },
                 body: JSON.stringify({
                     ...payload,
-                    environment: this.config.environment,
                     eventVersion: '1.0'
                 })
-            }).catch(() => {
-                /* Silently fail to protect the user's production app */
+            })
+                .then(() => { })
+                .catch(() => { })
+                .finally(() => {
+                this.pendingPromises.delete(promise);
             });
+            this.pendingPromises.add(promise);
         }
-        catch (e) {
-            /* Silently fail */
-        }
+        catch (e) { }
     }
     wrapOpenAI() {
         try {
-            // Detect if OpenAI is installed
             const OpenAI = require('openai');
             if (!OpenAI || !OpenAI.OpenAI)
                 return;
@@ -63,14 +107,19 @@ class MyNitor {
             OpenAI.OpenAI.Chat.Completions.prototype.create = async function (...args) {
                 const start = Date.now();
                 const body = args[0];
+                const callsite = self.getCallSite();
                 try {
                     const result = await originalChatCreate.apply(this, args);
                     const end = Date.now();
-                    // Background capture
                     self.sendEvent({
                         requestId: result.id || `req_${Date.now()}`,
                         model: result.model || body.model,
                         provider: 'openai',
+                        agent: 'default-agent',
+                        workflow: callsite.workflowGuess,
+                        file: callsite.file,
+                        functionName: callsite.functionName,
+                        lineNumber: callsite.line,
                         inputTokens: result.usage?.prompt_tokens || 0,
                         outputTokens: result.usage?.completion_tokens || 0,
                         latencyMs: end - start,
@@ -84,8 +133,10 @@ class MyNitor {
                         requestId: `err_${Date.now()}`,
                         model: body?.model || 'unknown',
                         provider: 'openai',
-                        inputTokens: 0,
-                        outputTokens: 0,
+                        agent: 'default-agent',
+                        workflow: callsite.workflowGuess,
+                        file: callsite.file,
+                        functionName: callsite.functionName,
                         latencyMs: end - start,
                         status: 'error',
                         errorType: error?.constructor?.name || 'Error'
@@ -94,11 +145,9 @@ class MyNitor {
                 }
             };
         }
-        catch (e) {
-            // Library not found or version mismatch - skip silently
-        }
+        catch (e) { }
     }
 }
 exports.MyNitor = MyNitor;
-// Global accessor for snippet simplicity
+// Global accessor
 exports.init = MyNitor.init;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mynitorai/sdk",
-    "version": "0.1.1",
+    "version": "0.1.4",
     "description": "Production safety and observability for AI systems.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",