Movatterモバイル変換


[0]ホーム

URL:


Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

Sign up
Appearance settings

A TypeScript library for tracing and visualizing code execution workflows.

License

NotificationsYou must be signed in to change notification settings

tabkram/execution-engine

Repository files navigation

execution-engine on npmnpminstall sizeBundle sizeCoverage StatusDependenciesGithub repoGitHub Repo starsGitHub licenseDocumentationjsDocs.io

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 ✨

Features are divided into two main parts:

1. Execution:

  • 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.

2. Engine:

  • 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.

Installation 📦

Usenpm package manager:

npm install execution-engine

Or use theyarn package manager:

yarn add execution-engine

Usage 📚


1. Execution:

Example 1: Memoization with@memoize

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.

Example 2: Caching Results with@cache

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.

Example 3: Tracing with@trace

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,@tracelogs the method execution, including input parameters, output, timing, duration, start time, end time, and elapsed time.


2. Engine:

Example 1: Basic Usage

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:

Example 2: Usage with Decorators

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:

Understanding the Trace 🧭

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}];

Examples 📘

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.

Documentation 📔

Explore the comprehensivedocumentation for this project.

Changelog 📝

For a detailed list of changes, enhancements, and bug fixes, please refer to ourChangelog.

Contributing 🤝

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.

Community 👥

Loveexecution-engine ? Give our repo a star ⭐ ⬆️.

License 📄

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

Stars

Watchers

Forks

Sponsor this project

 

Packages

No packages published

Contributors2

  •  
  •  

[8]ページ先頭

©2009-2025 Movatter.jp