Complete usage.

Author: odeadglaz

src/hooks/index.js

@@ -33,13 +33,16 @@ const init = (executionContextMap) => (asyncId, type, triggerAsyncId) => {
 
         // Setting child process entry as ref to parent context
         executionContextMap.set(asyncId, {
-            ref
+            ref,
+            type,
+            created: Date.now()
         });
 
-        const { context = {}, children = [] } = executionContextMap.get(ref);
+        const { context = {}, children = [], ...meta } = executionContextMap.get(ref);
 
         // Adding current async as child to parent context in order to control cleanup better
         executionContextMap.set(ref, {
+            ...meta,
             context,
             children: [...children, asyncId]
         });
@@ -53,7 +56,7 @@ const init = (executionContextMap) => (asyncId, type, triggerAsyncId) => {
  * @param {Number} ref - The parent process ref asyncId
  */
 const onChildProcessDestroy = (executionContextMap, asyncId, ref) => {
-    const { children: parentChildren, context } = executionContextMap.get(ref);
+    const { children: parentChildren, context, ...meta } = executionContextMap.get(ref);
     const children = parentChildren.filter((id) => id !== asyncId);
 
     // Parent context will be released upon last child removal
@@ -64,6 +67,7 @@ const onChildProcessDestroy = (executionContextMap, asyncId, ref) => {
     }
 
     executionContextMap.set(ref, {
+        ...meta,
         context,
         children
     });

src/index.js

@@ -1,6 +1,6 @@
 const asyncHooks = require('async_hooks');
 const ExecutionContextResource = require('./lib/ExecutionContextResource')
-const { isProduction } = require('./lib');
+const { isProduction, monitorMap } = require('./lib');
 const { create: createHooks } = require('./hooks');
 const { ExecutionContextErrors } = require('./constants');
 
@@ -48,7 +48,9 @@ const createExecutionContext = () => {
             if (executionContextMap.has(asyncId)) handleError(ExecutionContextErrors.CONTEXT_ALREADY_DECLARED);
 
             executionContextMap.set(asyncId, {
+                asyncId,
                 context: { ...initialContext, executionId: asyncId },
+                created: Date.now(),
                 children: []
             });
         },
@@ -112,12 +114,7 @@ const createExecutionContext = () => {
          * @return {ExecutionMapUsage}
          */
         monitor: () => {
-            console.log('Minotir runnig');
-
-            return {
-                size: executionContextMap.size,
-                entries: [...executionContextMap.values()]
-            }
+            return monitorMap(executionContextMap);
         }
     };
 

src/lib/index.js

@@ -6,8 +6,42 @@ const PRODUCTION = 'production';
 
 const env = process.env.NODE_ENV || PRODUCTION;
 
+/**
+ * Calculates a duration between a given moment and now
+ * @param {Number} now - The current time
+ * @param {Number} created - The created time to calculate it's duration
+ * @return {Number}
+ */
+const getDuration = (now, created) => now - created
+
 module.exports = {
     env,
     isProduction: (environment = env) => environment === PRODUCTION,
-    isUndefined: (thing) => [null, undefined].includes(thing)
+    isUndefined: (thing) => [null, undefined].includes(thing),
+    /**
+     * Returns a monitoring report over the "executionContext" memory usage.
+     * @param {ExecutionContextMap} executionContextMap The execution map to monitor
+     * @return {ExecutionMapUsage}
+     */
+    monitorMap: (executionContextMap) => {
+        const now = Date.now();
+        const entries = [...executionContextMap.values()]
+            .filter(({ children }) => !!children)
+            .map(({ asyncId, created, children, context = {} }) => ({
+                asyncId,
+                created,
+                contextSize: JSON.stringify(context).length,
+                duration: getDuration(now, created),
+                children: children.map((childId) => {
+                    const { type, created } = executionContextMap.get(childId);
+
+                    return { asyncId: childId, type, created, duration: getDuration(now, created) }
+                })
+            }));
+
+        return {
+            size: executionContextMap.size,
+            entries
+        }
+    }
 };

src/spec.js

@@ -189,4 +189,20 @@ describe('Context', () => {
             });
         });
     });
+
+    describe('Monitor', () => {
+        describe('When no context is open', () => {
+            it('Returns empty usage', (done) => {
+                console.log(Context.monitor())
+
+                setTimeout(() => console.log(Context.monitor()), 1000)
+                setTimeout(() => console.log(Context.monitor()), 3000)
+                setTimeout(() => {
+                    console.log(Context.monitor())
+                    done();
+                }, 5000)
+
+            });
+        });
+    });
 });

src/types.d.ts

@@ -31,11 +31,21 @@ interface HookCallbacks {
     destroy?(asyncId: number): void;
 }
 
-interface ExecutionMapUsageEntry {
+interface ExecutionMapUsageBaseEntry {
     asyncId: number;
+    created: number;
+    duration: number;
+}
+
+interface ExecutionMapUsageChildEntry extends ExecutionMapUsageBaseEntry {
     type: string;
 }
 
+interface ExecutionMapUsageEntry extends ExecutionMapUsageBaseEntry {
+    asyncId: number;
+    children: ExecutionMapUsageChildEntry[];
+}
+
 interface ExecutionMapUsage {
     size: number;
     entries: ExecutionMapUsageEntry[];