Msgr: Rails-like Messaging Framework

Gem Version Build Status Coverage Status Code Climate Dependency Status RubyDoc Documentation

You know it and you like it. Using Rails you can just declare your routes and create a controller. That's all you need to process requests.

With Msgr you can do the same for asynchronous AMQP messaging. Just define your routes, create your consumer and watch your app processing messages.


Add this line to your application's Gemfile:

gem 'msgr'

And then execute:

$ bundle

Or install it yourself as:

$ gem install msgr


After adding 'msgr' to your gemfile create a config/rabbitmq.yml like this:

common: &common
  uri: amqp://localhost/

  <<: *common

  <<: *common

  <<: *common

Specify your messaging routes in config/msgr.rb:

route 'local.test.index', to: 'test#index'
route 'local.test.another_action', to: 'test#another_action'

Create your consumer in app/consumers:

class TestConsumer < Msgr::Consumer
  def index
    data = { fuubar: 'abc' }

    publish data, to: 'local.test.another_action'

  def another_action
    puts "#{payload.inspect}"

Use Msgr.publish in to publish a message:

class TestController < ApplicationController
  def index
    @data = { abc: 'abc' }

    Msgr.publish @data, to: 'local.test.index'

    render nothing: true

Msgr and fork web server like unicorn

Per default msgr opens the rabbitmq connect when rails is loaded. If you use a multi-process web server that preloads the application (like unicorn) will lead to unexpected behavior. In this case adjust config/rabbitmq.yml and adjust autostart = false:

common: &common
  uri: amqp://localhost/
  autostart: false

And call inside each worker Msgr.start - e.g. in an after-fork block


Recommended configuration

  <<: *common
  pool_class: Msgr::TestPool
  raise_exceptions: true

The Msgr::TestPool pool implementation executes all consumers synchronously. By enabling the raise_exceptions configuration flag, we can ensure that exceptions raised in a consumer will not be swallowed by dispatcher (which it usually does in order to retry consuming the message).

RSpec example

In your spec_helper.rb:

config.after(:each) do
  # Flush the consumer queue
  Msgr.client.stop delete: true

In a test:

before { Msgr.client.start }

it 'executes the consumer' do
  # Publish an event on our queue
  Msgr.publish 'payload', to: 'msgr.queue.my_queue'

  # Let the TestPool handle exactly one event count: 1

  # And finally, assert that something happened
  expect(actual).to eq expected


  1. Fork it
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Add some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create new Pull Request