Uh oh!
There was an error while loading.Please reload this page.
- Notifications
You must be signed in to change notification settings - Fork1
A TypeScript library for tracing and visualizing code execution workflows.
License
tabkram/execution-engine
Folders and files
Name | Name | Last commit message | Last commit date | |
---|---|---|---|---|
Repository files navigation
Execution Engine is a TypeScript library that enables tracing, visualization, and optimization of code executionworkflows. It provides tools to trace execution flow, manage caching, and optimize repeated computations, offeringinsights through structured execution traces in JSON format.
Features are divided into two main parts:
- Trace: Capture detailed execution flow for debugging and analysis.
- Cache: Prevent redundant function executions by storing results temporarily.
- Memoize: Optimize repeated computations within the same execution call.
- Tracing: Trace the execution flow of code within your project.
- Timing: Capture the timing of each executed function.
- Visualization: Generate traces in JSON format for clear and insightful visualization.
- Easily parseable into graphs using tools likejson-to-graph online demo.
Usenpm package manager:
npm install execution-engine
Or use theyarn package manager:
yarn add execution-engine
import{memoize}from"execution-engine";classCalculator{ @memoize()// Store the result of Fibonacci calculationsfibonacci(n:number):number{if(n<=1)returnn;returnthis.fibonacci(n-1)+this.fibonacci(n-2);}}constcalc=newCalculator();console.log(calc.fibonacci(10));// Calculates and stores resultconsole.log(calc.fibonacci(10));// Reuses pending result, no recalculation
In this example, thefibonacci
method is decorated with@memoize
, meaning repeated calls with the samen
will reuse the stored result instead of recalculating it.
import{cache}from"execution-engine";classExampleService{ @cache({ttl:5000})// Store result for 5 secondsasyncfetchData(id:number):Promise<string>{console.log('Fetching data...');return`Data for${id}`;}}constservice=newExampleService();console.log(awaitservice.fetchData(1));// Fetches data and stores itconsole.log(awaitservice.fetchData(1));// Reuses stored result (within ttl)
ThefetchData
method is decorated with@cache
, storing the result for 5 seconds. Subsequent calls within that time reuse the stored result.
import{trace}from"execution-engine";classMathOperations{ @trace(console.log)// Trace the execution and log using console.logadd(a:number,b:number):number{returna+b;}}constmathOps=newMathOperations();console.log(mathOps.add(2,3));// Traces the 'add' method execution and logs it
In this example,@trace
logs the method execution, including input parameters, output, timing, duration, start time, end time, and elapsed time.
import{ExecutionEngine}from"execution-engine";constengine=newExecutionEngine();// for sync functions:constres1=engine.run((param)=>`result1 for${param}`,['param1']);// for async functions:constres2=awaitengine.run(async(param)=>`result2 for${param}`,[res1.outputs]);// Retrieve the traceconsttrace=engine.getTrace();console.log('Trace:',trace);
You can:
- view thecomplete code inexamples/usage.ts
- inspect thetrace output inexamples/usage.json.
- visualize thetrace graph using the json-to-graph onlinetool.→ See the result ←
import{engine,run}from"execution-engine";@engine({id:"uniqueEngineId"})classMyClassextendsEngineTask{ @run()myMethod1(param:string){return`result1 for${param}`;} @run()asyncmyMethod2(param:string){return`result2 for${param}`;}}constmyInstance=newMyClass();myInstance.myMethod2("param1");awaitmyInstance.myMethod2("param2");// Retrieve the traceconsttrace=myInstance.engine.getTrace();console.log("Trace:",trace);
You can:
- view thecomplete code inexamples/usage2.ts
- inspect thetrace output inexamples/usage2.json
- visualize thetrace graph using the json-to-graph onlinetool.→ See the result ←
Thetrace
object is an array containingnodes andedges. It has the following structure:
trace=[{data:{id:function_uuid1,label:"function"//... other properties of the result of the executed function as mentioned above},group:nodes},{data:{id:function_uuid2,label:"function"//... other properties of the result of the executed function as mentioned above},group:nodes},{data:{id:function_uuid1->function_uuid2,source:function_uuid1,target:function_uuid2,parallel:false},group:edges}];
For additional usage examples, please explore the/examples directory in this repository.
You'll find a variety of scenarios showcasing the capabilities of Execution Engine.
Explore the comprehensivedocumentation for this project.
For a detailed list of changes, enhancements, and bug fixes, please refer to ourChangelog.
If you find any issues or have suggestions for improvement, feel free to open an issue or submit a pull request.Contributions are welcome!
Before getting started, please read ourContribution Guidelines.
Loveexecution-engine
? Give our repo a star ⭐ ⬆️.
This project is licensed under the MIT License - see theLICENSE file for details.
About
A TypeScript library for tracing and visualizing code execution workflows.
Topics
Resources
License
Code of conduct
Security policy
Uh oh!
There was an error while loading.Please reload this page.
Stars
Watchers
Forks
Sponsor this project
Uh oh!
There was an error while loading.Please reload this page.
Packages0
Uh oh!
There was an error while loading.Please reload this page.
Contributors2
Uh oh!
There was an error while loading.Please reload this page.