Queue

Flamingo makes it easy to wade through the Twitter Streaming API by handling all connectivity and resource management for you. You just tell it what to track and consume the information in a resque queue. Flamingo isn't a traditional ruby gem. You don't require it into your code. Instead, it's designed to run as a daemon like redis or mysql. It provides a REST interface to change the parameters sent to the Twitter Streaming resource. All events from the streaming API are placed on a resque job queue where your application can process them. CAVEAT EMPTOR: This gem is alpha code so act accordingly.

A unique queue with atomic operations implemented in Redis.

Rack middleware that allows easy external querying of your heroku's app queue depth

Ensures that for a given queue, only one worker is working on a job at any given time. Example: require 'resque/plugins/unique_at_runtime' class StrictlySerialJob include Resque::Plugins::UniqueAtRuntime @queue = :serial_work def self.perform # only one at a time in this block, no parallelism allowed for this # particular queue end end

em-posixmq integrates posix_mq Ruby library into the EventMachine reactor allowing asynchronous reading from a POSIX message queue

Library for working with rabbit queues

Mumbletune connects to a mumble server and allows users to interact with and play a queue of music from Spotify.

Monitors and controls running workflow robots off of priority queues and within a cluster

Mocktacular Companion to AMQP Library. Happy TATFTing!

Queuing system for Apple's Push Service on top of Resque. Adds methods enqueue_aps to queue a notification message. Also includes helper classes and methods to format JSON.

Messaging gateway API with adapters for many messaging systems available in Ruby. Messaging systems can be easily switched out with a small configuration change. Code for testing on the object and application level is also provided.

The Chimera http client offers an easy to learn interface and consistent error handling. It is lightweight, fast and enables you to queue HTTP requests to run them in parallel for better performance and simple aggregating of distributed data. Despite it's simple interface it allows for advanced features like using custom deserializers, loggers, caching requests individiually, and instrumentation support (soon to be implemented).

Gem for implementing Queue-it KnownUser V3

Grand Central Dispatch is natively implemented as a C API and runtime engine. This gem provides a MacRuby wrapper around that API and allows Ruby to very easily take advantage of GCD to run tasks in parrallel and do calculations asynchronously with queues automatically mapping to threads as needed.

Queue up calls to specific models and execute them in transactions, after a certain number of models have been added.

A library for storing and filtering documents on elastic search with a queue paradigm for retrieval.

Contains libraries that support defining, queueing, and executing jobs.

Monitors the delayed_job queue and periodically tests its ability to deliver e-mail messages and e-mails you if something goes wrong, such as the delayed_job process crashes or one of its jobs fails or takes too long to complete.

An AMQP-based background worker system for Ruby designed to make managing heterogenous tasks relatively easy. The use case for Woodhouse is for reliable and sane performance in situations where jobs on a single queue may vary significantly in length. The goal is to permit large numbers of quick jobs to be serviced even when many slow jobs are in the queue. A secondary goal is to provide a sane way for jobs on a given queue to be given special priority or dispatched to a server more suited to them. Clients (i.e., your application) may be using either Ruby 1.9 in any VM.

Redis reliable queue pattern implemented in Sidekiq

Resque-mongo is a MongoDB-backed Ruby library for creating background jobs, placing those jobs on multiple queues, and processing them later. \ Background jobs can be any Ruby class or module that responds to perform. Your existing classes can easily be converted to background jobs or you can create new classes specifically to do work. Or, you can do both. Resque is heavily inspired by DelayedJob (which rocks) and is comprised of three parts: \ * A Ruby library for creating, querying, and processing jobs * A Rake task for starting a worker which processes jobs * A Sinatra app for monitoring queues, jobs, and workers.

minitest-distributed is a plugin for minitest for executing tests on a distributed set of unreliable workers. When a test suite grows large enough, it inevitable gets too slow to run on a single machine to give timely feedback to developers. This plugins combats this issue by distributing the full test suite to a set of workers. Every worker is a consuming from a single queue, so the tests get evenly distributed and all workers will finish around the same time. Redis is used as coordinator, but when using this plugin without having access to Redis, it will use an in-memory coordinator. Using multiple (virtual) machines for a test run is an (additional) source of flakiness. To combat flakiness, minitest-distributed implements resiliency patterns, like re-running a test on a different worker on failure, and a circuit breaker for misbehaving workers.

A class atop sourcify and amqp which can queue stringified lambdas over RabbitMQ. It is untested on free variables.

scotttam-resque is an extension to the resque queue system that has pre-fork hooks and ability to turn off forking. Add more description here.

Qup is a generalized API for Message Queue and Publish/Subscribe messaging patterns with the ability to plug in an appropriate messaging infrastructure based upon your needs. Qup ships with support for (https://github.com/robey/kestrel), (http://redis.io), and a filesystem infrastructure based on (https://rubygems.org/gems/maildir). Additional Adapters will be developed as needs arise. (https://github.com/copiousfreetime/qup/issues) to have a new Adapter created. Pull requests gladly accepted.

Delayed Action is a controller concern that lets you queue long running requests in a DRY fashion to avoid timeouts

New Relic (on Heroku) currently reports queue times as queuing at the router level. The goal of this gem is to provide new relic with the proper queueing time for requests, which takes into account queue time at the dyno level.

ActiveTracker is a self-hosted website (combined with this rubygem) to track user requests through your logs, see errors raise and queue usage/failures

MobSpawner manages worker threads that can run arbitrary commands and report results. Unlike distributed queues, MobSpawner is self-contained and perfect for small batch scripts that need to run multiple independent jobs.

ruby queue is a zero-admin zero-configuration tool used to create instant unix clusters

A job queueing and background workers system using Beanstalkd. Inspired by the Minion gem.

A server populates a queue, this client downloads those files

Blue_colr provides simple DSL to enqueue processes in given order, using database table as a queue, and a deamon to run them

Delayed_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks. This gem is ajaycb's fork (http://github.com/ajaycb/delayed_job). Adds namesd queues for use in Rails 2.x

This is a Sidekiq extension that doesn't allow a job to be enqueued if it's already in the queue or being processed

== DESCRIPTION: NServer is a set of classes that provide a flexible notification system for Linux based systems. It sits in the systray, waiting for messages to be submitted for display. X.org standards (via Gtk) and libnotify are used. Messages can be submitted from the localhost, or via remote hosts, depending on settings. == FEATURES/PROBLEMS: * Persistent server with notification queueing * Uses X.org SYSTRAY specification (via gtk2) == SYNOPSIS:

take default Queue from Ruby and allow multiple operations while holding lock

A simple queue API with a maildir backend. Also includes an HTTP API

Proper related posts plugin for Jekyll - uses document correlation matrix on TF-IDF (optionally with Latent Semantic Indexing). Each document is tokenized and stemmed, every word found is treated as keyword for analysis (except for some stop words). TF-IDF matrix for the whole site is calculated (including extra provided weights), then if given accuraccy is lower than 1.0, LSI algorithm is used to compute new simplified vector space. Document correlation matrix is created using dot product of the matrix and its transpose. For each of the post' related documents are inserted into priority queue (sorted by score from document correlation matrix), assuming the score is greater than minimal required score. Selected few bests related posts are retrieven from the queue. Liquid template for each post is rendered and <related-posts /> is replaced with the outcomes of algorithm.

Little gem to enqueue jobs the easy way

== DESCRIPTION: The RightScale AWS gems have been designed to provide a robust, fast, and secure interface to Amazon EC2, EBS, S3, SQS, SDB, and CloudFront. These gems have been used in production by RightScale since late 2006 and are being maintained to track enhancements made by Amazon. The RightScale AWS gems comprise: - RightAws::Ec2 -- interface to Amazon EC2 (Elastic Compute Cloud) and the associated EBS (Elastic Block Store) - RightAws::S3 and RightAws::S3Interface -- interface to Amazon S3 (Simple Storage Service) - RightAws::Sqs and RightAws::SqsInterface -- interface to first-generation Amazon SQS (Simple Queue Service) (API version 2007-05-01) - RightAws::SqsGen2 and RightAws::SqsGen2Interface -- interface to second-generation Amazon SQS (Simple Queue Service) (API version 2008-01-01) - RightAws::SdbInterface and RightAws::ActiveSdb -- interface to Amazon SDB (SimpleDB) - RightAws::AcfInterface -- interface to Amazon CloudFront, a content distribution service == FEATURES:

A simple Resque plugin that times and saves some simple metrics for Resque jobs back into redis. Based on this system you could build some simple auto-scaling mechanism based on the speed and ETA of queues. Also includes a hook/callback mechanism for recording/sending the metrics to your favorite tool (AKA statsd/graphite).

resque plugin that allows you to attach information when a job is put in redis, and to do whatever you want with the information when it is popped off the resque queue

simplistic postgresql based queue with support for batching and idempotent operations

Have you ever had a class whose instances required a series of background tasks to run serially, strictly one after another? Than Serially is for you. Declare the tasks using a simple DSL in the order you want them to to run. The tasks for each instance will run inside a separate Resque job, in a queue you specify. The next task will run only if the previous one has finished successfully. All task runs are written to DB and can be inspected.

Simple Queue Service accessing library

A queue that refreshes itself when it gets empty or stale, so you can keep popping

ProcessPool with interchangeable job queue backends for Ruby

Play/Manage RabbitMQ. Vhosts, queues.

Description of QueuedMail.