delayed_rabbit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1dacae11a213b6fb4a5e38990cd2667a447a5404c87996d4f3cc519b3d55e943
+  data.tar.gz: b7372e3ab221c15fc15d759379d9fcc290931193c4bc18e5e3fcb49d3211da04
+SHA512:
+  metadata.gz: dd439f723913b5c917711bd2e258eb7241cf6c7eb63f1f2b2f21ef8e8a981aaa1af1e98ae883c422b3975f22fa517a968c564af4e81f8d796f16801a4d739351
+  data.tar.gz: 52342b65ff0a262378938d9a69eef7b40c643d3ef2b47b5369b4a897b0c372a3fdb7be3b511e4a6d31dddfc4a7ac63fa7da125b8554b28b169ba873152d873fa

data/README.md

@@ -0,0 +1,284 @@
+# Delayed Rabbit
+
+A lightweight Ruby gem for scheduling delayed background jobs using RabbitMQ's delayed message exchange plugin.
+
+## Features
+
+- Schedules jobs with custom delays using RabbitMQ's x-delayed-message plugin
+- Uses JSON serialization for job data
+- Configurable exchange and queue settings
+- Simple API for publishing delayed jobs
+- Rails integration support
+- Automatic connection management
+- Persistent message delivery
+- Support for custom routing keys
+- Dead-letter queue support
+
+## Requirements
+
+- Ruby 3.2+
+- RabbitMQ 3.8+ with x-delayed-message plugin enabled
+- Bunny gem (~> 2.18)
+- JSON serialization support
+
+## Installation
+
+### Enabling RabbitMQ Plugin
+
+Before using this gem, you need to enable the delayed message plugin in RabbitMQ:
+
+```bash
+rabbitmq-plugins enable rabbitmq_delayed_message_exchange
+```
+
+### Ruby Gem Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'delayed_rabbit'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install delayed_rabbit
+```
+
+## Usage
+
+### Basic Usage
+
+```ruby
+require 'delayed_rabbit'
+
+# Create a publisher with custom connection options
+publisher = DelayedRabbit::JobPublisher.new(
+  connection_options: {
+    host: "localhost",
+    port: 5672,
+    user: "guest",
+    password: "guest",
+    vhost: "/"
+  }
+)
+
+# Publish a job with 5000ms (5 seconds) delay
+job_data = {
+  type: "email_notification",
+  recipient: "user@example.com",
+  subject: "Delayed Email",
+  body: "This email was sent after a delay"
+}
+
+# Publish with custom routing key
+publisher.publish(job_data, delay_ms: 5000, routing_key: "notifications.email")
+
+# Close the connection when done
+publisher.close
+```
+
+### Using with Rails
+
+1. Add the gem to your Gemfile
+2. Run the rake task to enqueue a test job:
+
+```bash
+bundle exec rake delayed_rabbit:enqueue_test_job[5000]
+```
+
+You can also create your own rake tasks for specific job types:
+
+```ruby
+namespace :jobs do
+  desc "Enqueue a notification job"
+  task :enqueue_notification, [:delay_ms, :user_id] => :environment do |t, args|
+    delay_ms = args[:delay_ms].to_i || 5000
+    user_id = args[:user_id]
+    
+    job_data = {
+      type: "notification",
+      user_id: user_id,
+      message: "Welcome notification"
+    }
+
+    DelayedRabbit::JobPublisher.publish(job_data, delay_ms: delay_ms, routing_key: "notifications.#{user_id}")
+  end
+end
+```
+
+### Advanced Usage
+
+#### Custom Exchange Configuration
+
+```ruby
+publisher = DelayedRabbit::JobPublisher.new(
+  exchange_options: {
+    type: "x-delayed-message",
+    durable: true,
+    auto_delete: false,
+    arguments: {"x-delayed-type" => "direct"}  # Change to direct exchange
+  }
+)
+```
+
+#### Custom Queue Configuration
+
+```ruby
+publisher = DelayedRabbit::JobPublisher.new(
+  queue_options: {
+    durable: true,
+    exclusive: false,
+    auto_delete: false,
+    arguments: {
+      "x-dead-letter-exchange" => "dlx_exchange",
+      "x-dead-letter-routing-key" => "dlx_key",
+      "x-message-ttl" => 3600000  # 1 hour TTL
+    }
+  }
+)
+```
+
+#### Using with Rails Environment
+
+You can configure different settings based on Rails environment:
+
+```ruby
+# config/initializers/delayed_rabbit.rb
+DelayedRabbit.configure do |config|
+  config.connection_options = {
+    host: Rails.env.production? ? "rabbitmq-prod" : "localhost",
+    port: 5672,
+    user: Rails.application.credentials.rabbitmq[:user],
+    password: Rails.application.credentials.rabbitmq[:password]
+  }
+end
+```
+
+## Configuration Options
+
+### Connection Options
+
+- `host`: RabbitMQ server hostname
+- `port`: RabbitMQ server port (default: 5672)
+- `user`: Username for authentication
+- `password`: Password for authentication
+- `vhost`: Virtual host to connect to (default: "/")
+- `automatic_recovery`: Enable automatic connection recovery
+- `network_recovery_interval`: Time between recovery attempts
+
+### Exchange Options
+
+- `type`: Exchange type (default: "x-delayed-message")
+- `durable`: If true, exchange will survive broker restarts
+- `auto_delete`: If true, exchange will be deleted when last queue unbinds
+- `arguments`: Additional exchange arguments
+
+### Queue Options
+
+- `durable`: If true, queue will survive broker restarts
+- `exclusive`: If true, queue can only be consumed by this connection
+- `auto_delete`: If true, queue will be deleted when last consumer disconnects
+- `arguments`: Additional queue arguments (e.g., TTL, dead-letter exchange)
+
+## Development
+
+### Setting Up Development Environment
+
+1. Clone the repository
+2. Install dependencies:
+```bash
+gem install bundler
+bundle install
+```
+
+3. Run the test suite:
+```bash
+bundle exec rake test
+```
+
+4. Start the development console:
+```bash
+bundle exec irb -Ilib -rdelayed_rabbit
+```
+
+### Running Tests
+
+The test suite requires a running RabbitMQ instance with the delayed message plugin enabled. You can run tests with:
+
+```bash
+bundle exec rake test
+```
+
+### Releasing a New Version
+
+1. Update the version number in `lib/delayed_rabbit/version.rb`
+2. Run the release command:
+```bash
+bundle exec rake release
+```
+
+This will:
+- Create a git tag for the version
+- Push git commits and tags
+- Push the `.gem` file to rubygems.org
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -am 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Create a Pull Request
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Plugin Not Enabled**
+   - Ensure the delayed message plugin is enabled in RabbitMQ
+   - Run: `rabbitmq-plugins enable rabbitmq_delayed_message_exchange`
+
+2. **Connection Issues**
+   - Verify RabbitMQ server is running
+   - Check connection credentials
+   - Verify network connectivity
+
+3. **Message Not Received**
+   - Check if exchange exists
+   - Verify queue bindings
+   - Check message TTL settings
+
+### Debugging Tips
+
+1. Enable Bunny logging:
+```ruby
+Bunny.logger.level = Logger::DEBUG
+```
+
+2. Use RabbitMQ management UI to:
+   - Monitor exchanges and queues
+   - Check message delivery
+   - View connection status
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Support
+
+For support, please:
+1. Check the documentation
+2. Search existing issues
+3. Open a new issue if needed
+4. For urgent issues, consider professional support options
+
+## Security
+
+If you discover a security vulnerability, please contact the maintainers directly instead of opening a public issue. We will work to address the vulnerability as quickly as possible.

data/delayed_rabbit.gemspec

@@ -0,0 +1,36 @@
+require_relative "lib/delayed_rabbit/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "delayed_rabbit"
+  spec.version       = DelayedRabbit::VERSION
+  spec.authors       = ["Your Name"]
+  spec.email         = ["your.email@example.com"]
+
+  spec.summary       = "A lightweight Ruby gem for scheduling delayed background jobs using RabbitMQ"
+  spec.description   = "delayed_rabbit provides a simple interface for scheduling background jobs with delays using RabbitMQ's delayed message exchange plugin"
+  spec.homepage      = "https://github.com/yourusername/delayed_rabbit"
+  spec.license       = "MIT"
+  spec.required_ruby_version = "~> 3.2"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "bunny", "~> 2.18"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+end

data/example.rb

@@ -0,0 +1,26 @@
+require_relative "lib/delayed_rabbit"
+
+# Example job data
+job_data = {
+  type: "email_notification",
+  recipient: "user@example.com",
+  subject: "Delayed Email",
+  body: "This email was sent after a delay"
+}
+
+# Create a publisher with custom connection options
+publisher = DelayedRabbit::JobPublisher.new(
+  connection_options: {
+    host: "localhost",
+    port: 5672,
+    user: "guest",
+    password: "guest"
+  }
+)
+
+# Publish a job with 5000ms (5 seconds) delay
+message = publisher.publish(job_data, delay_ms: 5000)
+puts "Published delayed job: #{message}"
+
+# Close the connection
+publisher.close

data/lib/delayed_rabbit/job_publisher.rb

@@ -0,0 +1,69 @@
+require "bunny"
+require "json"
+
+module DelayedRabbit
+  class JobPublisher
+    DEFAULT_EXCHANGE_NAME = "delayed_jobs"
+    DEFAULT_EXCHANGE_TYPE = "x-delayed-message"
+    DEFAULT_DELAYED_QUEUE_NAME = "delayed_jobs_queue"
+    DEFAULT_DELAYED_QUEUE_ROUTING_KEY = "delayed_jobs"
+
+    attr_reader :connection, :channel, :exchange
+
+    def initialize(connection_options = {}, exchange_options = {}, queue_options = {})
+      @connection = Bunny.new(connection_options)
+      @connection.start
+      @channel = @connection.create_channel
+      
+      # Configure exchange
+      @exchange_options = {
+        type: DEFAULT_EXCHANGE_TYPE,
+        durable: true,
+        arguments: {"x-delayed-type" => "topic"}
+      }.merge(exchange_options)
+      
+      @exchange = @channel.topic(DEFAULT_EXCHANGE_NAME, @exchange_options)
+      
+      # Configure queue
+      @queue_options = {
+        durable: true,
+        arguments: {
+          "x-dead-letter-exchange" => DEFAULT_EXCHANGE_NAME,
+          "x-dead-letter-routing-key" => DEFAULT_DELAYED_QUEUE_ROUTING_KEY
+        }
+      }.merge(queue_options)
+      
+      @queue = @channel.queue(DEFAULT_DELAYED_QUEUE_NAME, @queue_options)
+      @queue.bind(@exchange, routing_key: DEFAULT_DELAYED_QUEUE_ROUTING_KEY)
+    end
+
+    def publish(job_data, delay_ms: 0, routing_key: DEFAULT_DELAYED_QUEUE_ROUTING_KEY)
+      raise ArgumentError, "Delay must be a non-negative integer" if delay_ms < 0
+
+      message = {
+        job_data: job_data,
+        timestamp: Time.now.to_i
+      }.to_json
+
+      @exchange.publish(
+        message,
+        headers: {"x-delay" => delay_ms},
+        routing_key: routing_key,
+        persistent: true
+      )
+      
+      message
+    end
+
+    def close
+      @connection.close if @connection.open?
+    end
+
+    def self.publish(job_data, delay_ms: 0, routing_key: DEFAULT_DELAYED_QUEUE_ROUTING_KEY, **options)
+      publisher = new(**options)
+      message = publisher.publish(job_data, delay_ms: delay_ms, routing_key: routing_key)
+      publisher.close
+      message
+    end
+  end
+end

data/lib/delayed_rabbit/version.rb

@@ -0,0 +1,3 @@
+module DelayedRabbit
+  VERSION = "0.1.0"
+end

data/lib/delayed_rabbit.rb

@@ -0,0 +1,6 @@
+require "delayed_rabbit/version"
+require "delayed_rabbit/job_publisher"
+
+module DelayedRabbit
+  # Your code goes here...
+end

data/tasks/delayed_rabbit.rake

@@ -0,0 +1,17 @@
+require "delayed_rabbit"
+
+namespace :delayed_rabbit do
+  desc "Enqueue a test job with delay"
+  task :enqueue_test_job, [:delay_ms] => :environment do |t, args|
+    delay_ms = args[:delay_ms].to_i || 5000 # Default to 5 seconds
+    
+    job_data = {
+      type: "test_job",
+      timestamp: Time.now.to_i,
+      message: "This is a test job enqueued with delayed_rabbit"
+    }
+
+    DelayedRabbit::JobPublisher.publish(job_data, delay_ms: delay_ms)
+    puts "Enqueued test job with #{delay_ms}ms delay"
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: delayed_rabbit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Your Name
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.18'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: delayed_rabbit provides a simple interface for scheduling background
+  jobs with delays using RabbitMQ's delayed message exchange plugin
+email:
+- your.email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- delayed_rabbit.gemspec
+- example.rb
+- lib/delayed_rabbit.rb
+- lib/delayed_rabbit/job_publisher.rb
+- lib/delayed_rabbit/version.rb
+- tasks/delayed_rabbit.rake
+homepage: https://github.com/yourusername/delayed_rabbit
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/yourusername/delayed_rabbit
+  source_code_uri: https://github.com/yourusername/delayed_rabbit
+  changelog_uri: https://github.com/yourusername/delayed_rabbit/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: A lightweight Ruby gem for scheduling delayed background jobs using RabbitMQ
+test_files: []