async-job 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2f85e329bfcf07e41d2e4f560e98fe4f23d12890291e0b474d2277e686f1326
-  data.tar.gz: f9113aef05940a7e575f0b340949779e22137e386ea4e4e102e95099103eade0
+  metadata.gz: b2e3a0d320ec9bea1f6e7417bba2e2d6f738e217fe234a78e411d968fd85e358
+  data.tar.gz: d516887d48045aad5e9f88b71884fbbfb49c07bbaaf7da117d3c02d410483400
 SHA512:
-  metadata.gz: 567e1c3ba3cd2713aba682f6f6d3cc69e136a6dc286f6e48949d11cf405fbb96352e5a0106c35b43985851defc12c83b8eaf54c4161d4e5b56cbaf685e7100e6
-  data.tar.gz: c48df37603abd9bb18b0b68eca416743331b90446e59ccecc885b145e3b3900173e3f65652fca639054a6f785c1f300b76497816a94e1b43fd8b333886ed2442
+  metadata.gz: 10ea8b43a19ca2d8aac3f99589d8b049bb64fca9e0c517ceed85071f08ac40e95396bc6c95aee4c2a995e726cfdca5abd3704066deb03f9629842e679435c0c6
+  data.tar.gz: 1e5aa618908e7caf4eaa2caa034557603a87e3e2a435ab13d16a1d253977ea0163bd46643f059800fe17db05152ecc3220e3b8dfd255dec762f93b2fbcc58317

checksums.yaml.gz.sig

@@ -1,3 +1,2 @@
-�G@��m�\���9�P�!3�ז��u�x��h�,mCR9�};6��(ʝ�W�!%��=��'m���t�j"�]
- �6۬,����#�����9��~h��%���"c/�����t�E���Z�sI�ٷ��|�Z-!��MI.�
-hB׉���I�'�#=�)�`�,��=��"$�9�Q@���$J��w2��ɠ�/�%\po!j�'Rx��0C�F��'�$Y��U�Z�,�eA֘h��j�G��8�L;�c������1�ܹ�qV�N�4�?��
+'�
+i5

data/context/aggregate-queue.md

@@ -0,0 +1,19 @@
+# Aggregate Queue
+
+This guide explains how to use the Aggregate queue to reduce input latency and improve the performance of your application.
+
+## Overview
+
+The {ruby Async::Job::Queue::Aggregate} queue is designed to reduce front-end processing latency by accumulating multiple jobs which are then processed together. This is particularly useful when you are scheduling jobs during a request-response cycle, as it allows you to move processing latency to a background task. However, as a consequence, it may reduce the overall robustness of your application, as a failure during processing may result in jobs being lost. The aggregate queue tries to mitigate this risk by ensuring all pending jobs are processed before the application exits, but it is not guaranteed.
+
+## Usage
+
+You can add the aggregate queue to an existing queue:
+
+~~~ ruby
+pipeline = Async::Job::Builder.build(buffer) do
+	# Aggregating before passing the job into Redis will avoid Redis latency issues affecting the front-end:
+	enqueue Async::Job::Queue::Aggregate
+	dequeue Async::Job::Queue::Redis
+end
+~~~

data/context/getting-started.md

@@ -0,0 +1,75 @@
+# Getting Started
+
+This guide gives you an overview of the `async-job` gem and explains the core concepts.
+
+## Installation
+
+Add the gem to your project:
+
+``` shell
+$ bundle add async-job
+```
+
+## Core Concepts
+
+`async-job` is a library for building asynchronous job queues.
+
+- Several included {ruby Async::Job::Queue} implementations for enqueueing and running jobs.
+- Several supported {ruby Async::Job::Coder} implementations for encoding and decoding job payloads.
+- A {ruby Async::Job::Generic} class which describes the minimum required job interface.
+
+The `async-job` library provides a framework for enqueueing and dequeuing jobs, without prescribing how jobs are executed. It is expected that you would use this library to wrap existing schemas for job definition and execution. This design allows you to use `async-job` in a wide variety of applications, without the need for cumbersome wrappers.
+
+## Usage
+
+In general, a job processing system pipeline comprises two parts: a client that submits jobs into a queue, and a server that reads jobs out of a queue and processes them.
+
+```mermaid
+sequenceDiagram
+	participant A as Client (Application)
+	participant ME as Middleware (Enqueue)
+	participant S as Server (Queue)
+	participant MD as Middleware (Dequeue)
+	participant H as Delegate
+
+	Note over A,S: Client
+	A->>+ME: Submit Job
+	ME->>+S: Enqueue Job
+
+	Note over S,H: Server
+	S->>+MD: Dequeue Job
+	MD->>+H: Execute Job
+```
+
+You can use {ruby Async::Job::Builder} to create a pipeline that includes both the producer and consumer sides of a queue:
+
+```ruby
+require "async"
+require "async/job"
+require "async/job/processor/inline"
+
+# This is how we execute a job from the queue:
+executor = proc do |job|
+	puts "Processing job: #{job}"
+end
+
+# Create a simple inline pipeline:
+pipeline = Async::Job::Builder.build(executor) do
+	# We are going to use an inline processor which processes the job in the background using Async{}:
+	enqueue Async::Job::Processor::Inline
+end
+
+# Enqueue a job:
+Async do
+	pipeline.call("My job")
+	# Prints "Processing job: My job"
+end
+```
+
+## Rails Integration
+
+You can use `async-job` with Rails's ActiveJob framework by using the `async-job-adapter-active_job` gem. This allows you to use `async-job` as a backend for ActiveJob, which is useful for integrating with existing Rails applications.
+
+### Redis Processor
+
+The `async-job-processor-redis` gem provides a Redis-based processor for `async-job`. This processor is similar to Sidekiq, and is designed to provide a similar interface and feature set.

data/context/index.yaml

@@ -0,0 +1,20 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+description: An asynchronous job queue for Ruby.
+metadata:
+  documentation_uri: https://socketry.github.io/async-job/
+  source_code_uri: https://github.com/socketry/async-job
+files:
+- path: getting-started.md
+  title: Getting Started
+  description: This guide gives you an overview of the `async-job` gem and explains
+    the core concepts.
+- path: inline-queue.md
+  title: Inline Queue
+  description: This guide explains how to use the Inline queue to execute background
+    jobs.
+- path: aggregate-queue.md
+  title: Aggregate Queue
+  description: This guide explains how to use the Aggregate queue to reduce input
+    latency and improve the performance of your application.

data/context/inline-queue.md

@@ -0,0 +1,17 @@
+# Inline Queue
+
+This guide explains how to use the Inline queue to execute background jobs.
+
+## Overview
+
+The {ruby Async::Job::Queue::Inline} queue is designed to process jobs in the background using the `Async` framework. This is particularly useful when you want to execute jobs in the same process as the client, but in a separate task. The inline queue is ideal for low-latency jobs that do not require transactional consistency.
+
+## Usage
+
+You can use the inline queue for dequeueing and executing jobs:
+
+~~~ ruby
+pipeline = Async::Job::Builder.build(buffer) do
+	dequeue Async::Job::Queue::Inline
+end
+~~~

data/lib/async/job/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module Job
-		VERSION = "0.11.0"
+		VERSION = "0.11.1"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-job
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -74,6 +74,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- context/aggregate-queue.md
+- context/getting-started.md
+- context/index.yaml
+- context/inline-queue.md
 - lib/async/job.rb
 - lib/async/job/buffer.rb
 - lib/async/job/builder.rb