Rpush aims to be the de facto gem for sending push notifications in Ruby. Its core goals are ease of use, reliability and a rich feature set. Rpush provides numerous advanced features not found in others gems, giving you greater control & insight as your project grows. These are a few of the reasons why companies worldwide rely on Rpush to deliver their notifications.

• Apple Push Notification Service
  • Including Safari Push Notifications.
• Firebase Cloud Messaging (used to be Google Cloud Messaging)
• Amazon Device Messaging
• Windows Phone Push Notification Service
• Pushy

• Use ActiveRecord or Redis for storage. Note: Redis support for Rails 5.2 is not yet working if you're using Modis, see this issue.
• Plugins for Bugsnag, Sentry, StatsD or write your own.
• Seamless integration with your projects, including Rails.
• Run as a daemon, inside a job queue, on the command-line or embedded in another process.
• Scales vertically (threading) and horizontally (multiple processes).
• Designed for uptime - new apps are loaded automatically, signal HUP to update running apps.
• Hooks for fine-grained instrumentation and error handling (Reflection API).
• Tested with MRI

Add it to your Gemfile:

gem 'rpush'

Initialize Rpush into your project. Rails will be detected automatically.

$ cd /path/to/project
$ bundle
$ bundle exec rpush init

If this is your first time using the APNs, you will need to generate SSL certificates. See Generating Certificates for instructions.

app = Rpush::Apns::App.new
app.name = "ios_app"
app.certificate = File.read("/path/to/sandbox.pem")
app.environment = "development" # APNs environment.
app.password = "certificate password"
app.connections = 1
app.save!

n = Rpush::Apns::Notification.new
n.app = Rpush::Apns::App.find_by_name("ios_app")
n.device_token = "..." # hex string
n.alert = "hi mom!"
n.data = { foo: :bar }
n.save!

The url_args attribute is available for Safari Push Notifications.

You should also implement the ssl_certificate_will_expire reflection to monitor when your certificate is due to expire.

To use the newer APNs Api replace Rpush::Apns::App with Rpush::Apns2::App.

To use the p8 APNs Api replace Rpush::Apns::App with Rpush::Apnsp8::App.

app = Rpush::Apnsp8::App.new
app.name = "ios_app"
app.apn_key = File.read("/path/to/sandbox.p8")
app.environment = "development" # APNs environment.
app.apn_key_id = "APN KEY ID"
app.team_id = "TEAM ID"
app.bundle_id = "BUNDLE ID"
app.connections = 1
app.save!

n = Rpush::Apns::Notification.new
n.app = Rpush::Apnsp8::App.find_by_name("ios_app")
n.device_token = "..." # hex string
n.alert = "hi mom!"
n.data = { foo: :bar }
n.save!

FCM and GCM are – as of writing – compatible with each other. See also this comment for further references.

Please refer to the Firebase Console on where to find your auth_key (probably called Server Key there). To verify you have the right key, use tools like Postman, HTTPie, curl or similar before reporting a new issue. See also this comment.

app = Rpush::Gcm::App.new
app.name = "android_app"
app.auth_key = "..."
app.connections = 1
app.save!

n = Rpush::Gcm::Notification.new
n.app = Rpush::Gcm::App.find_by_name("android_app")
n.registration_ids = ["..."]
n.data = { message: "hi mom!" }
n.priority = 'high'        # Optional, can be either 'normal' or 'high'
n.content_available = true # Optional
# Optional notification payload. See the reference below for more keys you can use!
n.notification = { body: 'great match!',
                   title: 'Portugal vs. Denmark',
                   icon: 'myicon'
                 }
n.save!

FCM also requires you to respond to Canonical IDs.

Check the FCM reference for what keys you can use and are available to you. Note: Not all are yet implemented in Rpush.

app = Rpush::Adm::App.new
app.name = "kindle_app"
app.client_id = "..."
app.client_secret = "..."
app.connections = 1
app.save!

n = Rpush::Adm::Notification.new
n.app = Rpush::Adm::App.find_by_name("kindle_app")
n.registration_ids = ["..."]
n.data = { message: "hi mom!"}
n.collapse_key = "Optional consolidationKey"
n.save!

For more documentation on ADM.

Uses the older Windows Phone 8 Toast template

app = Rpush::Wpns::App.new
app.name = "windows_phone_app"
app.client_id = # Get this from your apps dashboard https://dev.windows.com
app.client_secret = # Get this from your apps dashboard https://dev.windows.com
app.connections = 1
app.save!

n = Rpush::Wpns::Notification.new
n.app = Rpush::Wpns::App.find_by_name("windows_phone_app")
n.uri = "http://..."
n.data = {title:"MyApp", body:"Hello world", param:"user_param1"}
n.save!

Uses the more recent Toast template

The client_id here is the SID URL as seen here. Do not confuse it with the client_id on dashboard.

You can (optionally) include a launch argument by adding a launch key to the notification data.

You can (optionally) include an audio element by setting the sound on the notification.

app = Rpush::Wns::App.new
app.name = "windows_phone_app"
app.client_id = YOUR_SID_URL
app.client_secret = YOUR_CLIENT_SECRET
app.connections = 1
app.save!

n = Rpush::Wns::Notification.new
n.app = Rpush::Wns::App.find_by_name("windows_phone_app")
n.uri = "http://..."
n.data = {title:"MyApp", body:"Hello world", launch:"launch-argument"}
n.sound = "ms-appx:///mynotificationsound.wav"
n.save!

Note: The data is passed as .to_json so only this format is supported, altough raw notifications are meant to support any kind of data. Current data structure enforces hashes and .to_json representation is natural presentation of it.

n = Rpush::Wns::RawNotification.new
n.app = Rpush::Wns::App.find_by_name("windows_phone_app")
n.uri = 'http://...'
n.data = { foo: 'foo', bar: 'bar' }
n.save!

Uses the badge template and the type wns/badge.

n = Rpush::Wns::BadgeNotification.new
n.app = Rpush::Wns::App.find_by_name("windows_phone_app")
n.uri = 'http://...'
n.badge = 4
n.save!

Pushy is a highly-reliable push notification gateway, based on MQTT protocol for cross platform push notification delivery that includes web, Android, and iOS. One of its advantages is it allows for reliable notification delivery to Android devices in China where Google Cloud Messaging and Firebase Cloud Messaging are blocked and to custom hardware devices that use Android OS but are not using Google Play Services.

Note: current implementation of Pushy only supports Android devices and does not include subscriptions.

app = Rpush::Pushy::App.new
app.name = "android_app"
app.api_key = YOUR_API_KEY
app.connections = 1
app.save!

n = Rpush::Pushy::Notification.new
n.app = Rpush::Pushy::App.find_by_name("android_app")
n.registration_ids = ["..."]
n.data = { message: "hi mom!"}
n.time_to_live = 60 # seconds
n.save!

For more documentation on Pushy.

It is recommended to run Rpush as a separate process in most cases, though embedding and manual modes are provided for low-workload environments.

See rpush help for all available commands and options.

$ cd /path/to/project
$ rpush start

$ rpush push

Rpush will deliver all pending notifications and then exit.

Rpush.push
Rpush.apns_feedback

See Push API for more details.

if defined?(Rails)
  ActiveSupport.on_load(:after_initialize) do
    Rpush.embed
  end
else
  Rpush.embed
end

Call this during startup of your application, for example, by adding it to the end of config/rpush.rb. See Embedding API for more details.

If you're using mina, there is a gem called mina-rpush which helps you control rpush.

Rpush leaves delivered notifications in the database. If you do not clear them out, they will take up more and more space. This isn't great for any database, but is especially problematic if using Redis as the Rpush store. Here is an example solution for cleaning up delivered notifications in Redis.

See Configuration for a list of options.

You should run rpush init after upgrading Rpush to check for configuration and migration changes.

• Using Redis
• Using ActiveRecord
• Configuration
• Moving from Rapns
• Deploying to Heroku
• Hot App Updates
• Signals
• Reflection API
• Push API
• Embedding API
• Writing a Plugin
• Implementing your own storage backend
• Upgrading from 2.x to 3.0

• Generating Certificates
• Advanced APNs Features
• APNs Delivery Failure Handling
• Why open multiple connections to the APNs?
• Silent failures might be dropped connections

• Notification Options
• Canonical IDs
• Delivery Failures & Retries

Rpush uses Appraisal to run tests against multiple versions of Ruby on Rails. This helps making sure that Rpush performs correctly with multiple Rails versions.

Rpush also uses RSpec for its tests.

First, we need to setup a test database, rpush_test.

E.g. (postgres): psql -c 'create database rpush_test;' -U postgres >/dev/null

bundle install
bundle exec appraisal install

This will install all the required gems that requires to test against each version of Rails, which defined in gemfiles/*.gemfile.

bundle exec appraisal rake

This will run RSpec against all versions of Rails.

You need to specify a BUNDLE_GEMFILE pointing to the gemfile before running the normal test command:

BUNDLE_GEMFILE=gemfiles/rails_5.2.gemfile rspec spec/unit/apns_feedback_spec.rb

When running specs, please note that the ActiveRecord adapter can be changed by setting the ADAPTER environment variable. For example: ADAPTER=postgresql rake.

Available adapters for testing are postgresql, jdbcpostgresql, mysql2, jdbcmysql, jdbch2, and sqlite3.

Note that the database username is changed at runtime to be the currently logged in user's name. So if you're testing with mysql and you're using a user named 'bob', you will need to grant a mysql user 'bob' access to the 'rpush_test' mysql database.

To switch between ActiveRecord and Redis, set the CLIENT environment variable to either active_record or redis.