No description provided.
Seamless REST/GraphQL API mocking library for browser and Node.js.
Consistent Web Workers in browser and Node.
Distribute processing tasks to child processes with an über-simple API and baked-in durability & custom concurrency options.
A high-performance pure-javascript SHA1 implementation suitable for large binary data.
Utilities for executing code in Web Workers
Serialize JavaScript to a superset of JSON that includes regular expressions and functions.
A minimal and tiny Node.js Worker Thread Pool implementation, a fork of piscina, but with fewer features
A Node.js communication port that can pass messages synchronously between workers
Consistent Web Workers in browser and Node.
Create a promise that can be canceled
Use Rollup with workers and ES6 modules today.
Web workers & worker threads as simple as a function call
Webpack plugin to bundle Workers automagically.
Experimental Web Worker API implementation for JSDOM.
SQLite Wasm conveniently wrapped as an ES Module.
<img alt="Third Party Capital Logo" title="Third Party Capital Logo" src="https://user-images.githubusercontent.com/12476932/229881508-f9ef68db-8ee7-4795-8de8-80a50145bbd0.png" width="150">
Use Rollup with workers and ES6 modules today.
Offload tasks to a pool of workers on node.js and in the browser
A fast, efficient Node.js Worker Thread Pool implementation
A tiny (952b), correct, general-purpose, and configurable "exports" and "imports" resolver without file-system reliance
The worker which is used by the worker-timers package.
Temporal.io SDK Worker sub-package
worker loader module for webpack
Provides a simple task worker, with a task concurrency limit.
Simple thread pool/worker system for EventMachine
a simple em baseed background job worker.
Em-resque is a version of Resque, which offers non-blocking and non-forking workers. The idea is to have fast as possible workers for tasks with lots of IO like pinging third party servers or hitting the database. The async worker is using fibers through Synchrony library to reduce the amount of callback functions. There's one fiber for worker and if one of the workers is blocking, it will block all the workers at the same time. The idea to use this version and not the regular Resque is to reduce the amount of SQL connections for high-load services. Using one process for many workers gives a better control to the amount of SQL connections. For using Resque please refer the original project. https://github.com/defunkt/resque/ The library adds two rake tasks over Resque: * resque:work_async for working inside the EventMachine
Assemblage is a continuous integration toolkit. It's intended to provide you with a minimal infrastructure for distributing and performing automated tasks for one or more version control repositories. It makes as few assumptions as possible as to what those things might be. It's still just a personal project, but if you want to use it I'm happy to answer questions and entertain suggestions, especially in the form of patches/PRs. Assemblage has three primary parts: the **Assembly Server**, **Assembly Workers**, and **Repositories**. <dl> <dt>Assembly Server</dt> <dd>Aggregates and distributes events from <em>repositories</em> to <em>workers</em> via one or more "assemblies".</dd> <dt>Assembly Workers</dt> <dd>Listens for events published by the <em>assembly server</em>, checks out a <em>repository</em>, and runs an assembly script in that repository.</dd> <dt>Repository</dt> <dd>A distributed version control repository. Assemblage currently supports Mercurial and Git.</dd> </dl>
Application to gather prometheus style metrics # Usage Install the gem into your gemfile ```gem prometheus-collector``` Install your gemset ```bundle install``` Consume the program. ``` require 'prometheus/collector' class Guage < Prometheus::Collector::Extensions::Base install def run # Do some things that would be collected in Prometheus::Client Objects end end ``` Mount the Prometheus::Collector::Application application, or start it from your app.rb ``` Prometheus::Collector::Application.start ``` # How it works The collector app makes use of the Prometheus client collector and exporter middleware to allow you to write custom applications that export prometheus style metrics. It is designed as a bare-bones scaffold to get you off the ground with a ruby applet to get some statistics. It utilizes rack and its middleware. The interface is fairly straightforward: Your Metric Executing code needs to extend Prometheus::Collector::Extensions::Base for 'repeatedly-runbable' operations and Prometheus::Collector::Extensions::Once for something that should only be executed Once. Your class should implement an instance level `run` function, and may optionally implement a class level `schedule` function: This must return a `cron` style string to tell the application when to invoke your `run` code. By default, `schedule` is set to `* * * * *` which would allow the code to be executed every minute. ### Scheduling Scheduling is implemented via em-cron. Thus the re-scheduling of a task should occur within the parameters of the `schedule` string but is evaluated upon completion. Thus in normal operation, the code should not execute more than one `run` of a given worker definition at a time.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.