iron_mq 5.0.1 → 6.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de99bdc9d622017003d1e102420d9c0d28cfb18e
-  data.tar.gz: 5c83be6f01552a73dcd95d8be0410221a4dd500d
+  metadata.gz: 0885b055e2350a138614235f9ebb4e37b6492dba
+  data.tar.gz: ab9ee84981142ea6aaeca329e684450feeca04b9
 SHA512:
-  metadata.gz: f382fa201f071244adf25be870e6f575a711140a15e2c4b44a284365e92a78045112800868bb0ef00a904fd59dadf2b4b9aedf5c54bb367c0c7aed0eb292476a
-  data.tar.gz: a061b8a98b4271f93d063d058a1edf5da79e2d39206edeeaca78e6ac7dbb5ebb24848c104b84f16d08022bc941879ea4d1bef9c758441095815d3f777efac77f
+  metadata.gz: a11bd3d9f14934a8505d666600decf915512338a2a5b03837c35a3daa90dd2ea985a5202b30fe87b5f44571cf5b8b90e259288456b9fc2973427341ccf639c64
+  data.tar.gz: 3b1fc1c17f4e08eaa05401108b28e3ae1ebe25a00f401465d96841abe3695091e09416433452afe37ca79a28c5827d9f5b9918e5935de7d2ad11c92e01542e2e

data/.gitignore

@@ -7,4 +7,5 @@ test/config.yml
 *.sublime*
 /*.gem
 config.yml
+iron.json
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    iron_mq (5.0.0)
+    iron_mq (5.0.2)
       iron_core (>= 0.5.1)
 
 GEM
@@ -9,33 +9,34 @@ GEM
   specs:
     beanstalk-client (1.1.1)
     concur (2.1.1)
-    ethon (0.6.2)
+    ethon (0.7.1)
       ffi (>= 1.3.0)
-      mime-types (~> 1.18)
-    ffi (1.9.3)
+    ffi (1.9.5)
     go (1.1.0)
       concur
-    iron_core (1.0.3)
+    iron_core (1.0.5)
       rest (>= 2.6.4)
-    iron_worker_ng (1.2.0)
+    iron_worker_ng (1.5.0)
       bundler
       iron_core (>= 1.0.0)
-      rubyzip (>= 1.0.0)
-    mime-types (1.25.1)
-    minitest (5.2.3)
+      rubyzip (= 0.9.9)
+    minitest (5.4.2)
     net-http-persistent (2.9.4)
     netrc (0.7.7)
+    parallel (1.3.2)
+    power_assert (0.1.4)
     quicky (0.4.0)
-    rake (10.1.1)
-    rest (2.7.1)
+    rake (10.3.2)
+    rest (2.7.2)
       net-http-persistent (>= 2.9.1)
       rest_client (>= 1.7.1)
-    rest_client (1.7.2)
+    rest_client (1.7.3)
       netrc (~> 0.7.7)
-    rubyzip (1.1.0)
-    test-unit (2.5.5)
-    typhoeus (0.6.7)
-      ethon (~> 0.6.2)
+    rubyzip (0.9.9)
+    test-unit (3.0.1)
+      power_assert
+    typhoeus (0.6.9)
+      ethon (>= 0.7.1)
     uber_config (1.1.1)
 
 PLATFORMS
@@ -46,8 +47,9 @@ DEPENDENCIES
   go
   iron_mq!
   iron_worker_ng
-  minitest
+  minitest (>= 5.0)
   net-http-persistent
+  parallel
   quicky
   rake
   test-unit

data/README.md

@@ -7,13 +7,30 @@ much as possible so if you see an option in the API docs, you can use it in the
 **WARNING: Version 5+ has some small breaking changes. Version 4 ignored 404's on delete operations, Version
 5 will now raise exceptions.
 
+[Important Notes](#important-notes).
+
 ## Getting Started
 
 1\. Install the gem:
 
+<!---
+
 ```ruby
 gem install iron_mq
 ```
+-->
+
+We don't have v3 in rubygems yet, but you can use Bundler to easily use this gem. Add this to your Gemfile:
+
+```ruby
+gem 'iron_mq', git: 'https://github.com/iron-io/iron_mq_ruby.git', branch: 'v3'
+```
+
+Then do a `bundle update` and when executing, be sure to use `bundle exec` like so:
+
+```
+bundle exec ruby script.rb
+```
 
 2\. [Setup your Iron.io credentials](http://dev.iron.io/mq/reference/configuration/)
 
@@ -26,15 +43,48 @@ ironmq = IronMQ::Client.new
 Or pass in credentials if you don't want to use an iron.json file or set ENV variables:
 
 ```ruby
-ironmq = IronMQ::Client.new(:token => "MY_TOKEN", :project_id => "MY_PROJECT_ID")
+ironmq = IronMQ::Client.new(token: 'MY_TOKEN',
+                            project_id: 'MY_PROJECT_ID')
 ```
 You can also change the host if you want to use a different cloud or region, for example, to use Rackspace ORD:
 
 ```ruby
-ironmq = IronMQ::Client.new(:host => "mq-rackspace-ord.iron.io", :token => "MY_TOKEN", :project_id => "MY_PROJECT_ID")
+ironmq = IronMQ::Client.new(host: 'mq-rackspace-ord.iron.io',
+                            token:'MY_TOKEN',
+                            project_id: 'MY_PROJECT_ID')
 ```
 The default host is AWS us-east-1 zone (mq-aws-us-east-1.iron.io). [See all available hosts/clouds/regions](http://dev.iron.io/mq/reference/clouds/).
 
+### Keystone Authentication
+
+#### Via Configuration File
+
+Add `keystone` section to your iron.json file:
+
+```javascript
+{
+  "project_id": "57a7b7b35e8e331d45000001",
+  "keystone": {
+    "server": "http://your.keystone.host/v2.0/",
+    "tenant": "some-group",
+    "username": "name",
+    "password": "password"
+  }
+}
+```
+
+#### In Code
+
+```ruby
+keystone = {
+  server: "http://your.keystone.host/v2.0/",
+  tenant: "some-gorup",
+  username: "name",
+  password: "password"
+}
+client = IronMQ::Client.new(project_id: "57a7b7b35e8e331d45000001", keystone: keystone)
+```
+
 ## The Basics
 
 ### Get Queues List
@@ -50,7 +100,7 @@ list_queues = ironmq.queues # => [#<IronMQ::Queue:...>, ...]
 You can have as many queues as you want, each with their own unique set of messages.
 
 ```ruby
-queue = ironmq.queue("my_queue")
+queue = ironmq.queue('my_queue')
 ```
 
 Now you can use it.
@@ -63,7 +113,7 @@ Messages are placed on the queue in a FIFO arrangement.
 If a queue does not exist, it will be created upon the first posting of a message.
 
 ```ruby
-queue.post("hello world!")
+queue.post('hello world!')
 ```
 
 --
@@ -71,20 +121,23 @@ queue.post("hello world!")
 ### Retrieve Queue Information
 
 ```ruby
-queue.info # => {"id"=>"5127bf043264140e863e2283", "name"=>"my_queue", ...}
-queue.id   # => "5127bf043264140e863e2283"
+queue.info
+# => {"id"=>"5127bf043264140e863e2283", "name"=>"my_queue", ...}
+queue.id
+# => "5127bf043264140e863e2283"
 ```
 
 --
 
-### Get a Message off a Queue
+### Reserve/Get a Message from a Queue
 
 ```ruby
-msg = queue.get
-msg.body # => "hello world!"
+msg = queue.reserve
+msg.body
+# => "hello world!"
 ```
 
-When you pop/get a message from the queue, it is no longer on the queue but it still exists within the system.
+When you reserve a message from the queue, it is no longer on the queue but it still exists within the system.
 You have to explicitly delete the message or else it will go back onto the queue after the `timeout`.
 The default `timeout` is 60 seconds. Minimal `timeout` is 30 seconds.
 
@@ -100,6 +153,13 @@ queue.delete(msg.id)
 
 Be sure to delete a message from the queue when you're done with it.
 
+```ruby
+messages = queue.reserve(n: 3)
+queue.delete_reserved_messages(messages)
+```
+
+Delete reserved messages when you're done with it.
+
 --
 
 
@@ -108,25 +168,30 @@ Be sure to delete a message from the queue when you're done with it.
 `IronMQ::Client` is based on `IronCore::Client` and provides easy access to the queues.
 
 ```ruby
-ironmq = IronMQ::Client.new(:token => "MY_TOKEN", :project_id => "MY_PROJECT_ID")
+ironmq = IronMQ::Client.new(token: 'MY_TOKEN',
+                            project_id: 'MY_PROJECT_ID')
 ```
 
 ### List Queues
 
 ```ruby
-all_queues = ironmq.queues.list # => [#<IronMQ::Queue:...>, ...]
+all_queues = ironmq.queues.list
+# => [#<IronMQ::Queue:...>, ...]
 # or
-all_queues = ironmq.queues.all  # => [#<IronMQ::Queue:...>, ...]
+all_queues = ironmq.queues.all
+# => [#<IronMQ::Queue:...>, ...]
 ```
 
 **Optional parameters:**
 
-* `page`: The 0-based page to view. The default is 0.
-* `per_page`: The number of queues to return per page. The default is 30, the maximum is 100.
+* `per_page`: number of elements in response, default is 30.
+* `previous`: this is the last queue on the previous page, it will start from the next one. If queue with specified
+               name doesn’t exist result will contain first per_page queues that lexicographically greater than previous
+* `prefix`: an optional queue prefix to search on. e.g., prefix=ca could return queues `["cars", "cats", etc.]`
 * `raw`: Set it to true to obtain data in raw format. The default is false.
 
 ```ruby
-queues = ironmq.queues.all(:page => 1, :per_page => 10)
+queues = ironmq.queues.all(per_page: 10, previous: 'test_queue')
 ```
 
 --
@@ -134,7 +199,8 @@ queues = ironmq.queues.all(:page => 1, :per_page => 10)
 ### Get Queue by Name
 
 ```ruby
-queue = ironmq.queue "my_queue" # => #<IronMQ::Queue:...>
+queue = ironmq.queue('my_queue')
+# => #<IronMQ::Queue:...>
 ```
 
 **Note:** if queue with desired name does not exist it returns fake queue.
@@ -144,10 +210,101 @@ Queue will be created automatically on post of first message or queue configurat
 
 ## Queues
 
+### Create a Queue
+
+```ruby
+ironmq = IronMQ::Client.new
+options = {
+  message_timeout: 120,
+  message_expiration: 24 * 3600,
+  push: {
+    subscribers: [
+      {
+        name: 'subscriber_name',
+        url: 'http://rest-test.iron.io/code/200?store=key1',
+        headers: {
+          'Content-Type' => 'application/json'
+        }
+      }
+    ],
+    retries: 3,
+    retries_delay: 30,
+    error_queue: 'error_queue_name'
+  }
+}
+
+ironmq.create_queue(options)
+```
+
+**Options:**
+
+* `type`: String or symbol. Queue type. `:pull`, `:multicast`, `:unicast`. Field required and static.
+* `message_timeout`: Integer. Number of seconds before message back to queue if it will not be deleted or touched.
+* `message_expiration`: Integer. Number of seconds between message post to queue and before message will be expired.
+
+**Push queues only:**
+
+* `push: subscribers`: An array of subscriber hashes containing a `name` and a `url` required fields,
+and optional `headers` hash. `headers`'s keys are names and values are means of HTTP headers.
+This set of subscribers will replace the existing subscribers.
+To add or remove subscribers, see the add subscribers endpoint or the remove subscribers endpoint.
+See below for example json.
+* `push: retries`: How many times to retry on failure. Default is 3. Maximum is 100.
+* `push: retries_delay`: Delay between each retry in seconds. Default is 60.
+* `push: error_queue`: String. Queue name to post push errors to.
+
+--
+
+### Add subscribers to a push queue
+
+```ruby
+subscribers = [
+    {
+        name: 'first',
+        url: 'http://first.endpoint.xx/process',
+        headers: {
+            Content-Type: 'application/json'
+        }
+    },
+    {
+        name: 'second',
+        url: 'http://second.endpoint.xx/process',
+    }
+]
+queue.add_subscribers(subscribers)
+```
+
+### Replace subscribers on a push queue
+
+Sets list of subscribers to a queue. Older subscribers will be removed.
+
+```ruby
+subscribers = [
+    {
+        name: 'the_only',
+        url: 'http://my.over9k.host.com/push'
+    }
+]
+queue.replace_subscribers(subscribers);
+```
+
+### Remove subscribers by a name from a push queue
+
+```ruby
+subscribers = [
+    {
+        name: 'the_only'
+    }
+]
+queue.remove_subscribers(subscribers)
+```
+--
+
 ### Retrieve Queue Information
 
 ```ruby
-info = queue.info # => {"id"=>"5127bf043264140e863e2283", "name"=>"my_queue", ...}
+info = queue.info
+# => {"id"=>"5127bf043264140e863e2283", "name"=>"my_queue", ...}
 ```
 
 Shortcuts for `queue.info[key]`:
@@ -158,7 +315,8 @@ id = queue.id # => "5127bf043264140e863e2283"
 size = queue.size # => 7
 name = queue.name # => "my_queue"
 overall_messages = queue.total_messages # => 13
-subscribers = queue.subscribers # => [{"url" => "http://..."}, ...]
+subscribers = queue.subscribers
+# => [{"url" => "http://..."}, ...]
 
 push_type = queue.push_type # => "multicast"
 # Does queue Push Queue? Alias for `queue.push_type.nil?`
@@ -174,7 +332,7 @@ In this case you may prefer to use `queue.info` to have `Hash` with all availabl
 ### Delete a Message Queue
 
 ```ruby
-response = queue.delete_queue # => #<IronMQ::ResponseBase:...>
+response = queue.delete # => #<IronMQ::ResponseBase:...>
 ```
 
 --
@@ -184,9 +342,10 @@ response = queue.delete_queue # => #<IronMQ::ResponseBase:...>
 **Single message:**
 
 ```ruby
-response = queue.post("something helpful") # => #<IronMQ::ResponseBase:...>
+response = queue.post('something helpful') # => #<IronMQ::ResponseBase:...>
 # or
-response = queue.post("with parameteres", :timeout => 300) # => #<IronMQ::ResponseBase:...>
+response = queue.post('with parameteres', timeout: 300)
+# => #<IronMQ::ResponseBase:...>
 
 message_id = response.id # => "5847899158098068288"
 status_message = response.msg # => "Messages put on queue."
@@ -195,12 +354,14 @@ http_code = response.code # => 200
 
 **Multiple messages:**
 ```ruby
-# [{:body => VALUE}, ...] format is required
-messages = [{:body => "first"}, {:body => "second"}]
+# [{body: VALUE}, ...] format is required
+messages = [{body: 'first'}, {body: 'second'}]
 
-response = queue.post(messages) # => {"ids" => ["5847899158098068288", ...], "msg" => "Messages put on queue."}
+response = queue.post(messages)
+# => {"ids" => ["5847899158098068288", ...], "msg" => "Messages put on queue."}
 # or
-response = queue.post(messages, :timeout => 300) # => {"ids" => ["5847899158098068288", ...], "msg" => "Messages put on queue."}
+response = queue.post(messages, timeout: 300)
+# => {"ids" => ["5847899158098068288", ...], "msg" => "Messages put on queue."}
 ```
 
 **Optional parameters:**
@@ -220,23 +381,25 @@ Default is 604,800 seconds (7 days). Maximum is 2,592,000 seconds (30 days).
 ### Get Messages from a Queue
 
 ```ruby
-message = queue.get # => #<IronMQ::Message:...>
+message = queue.reserve # => #<IronMQ::Message:...>
 
 # or N messages
-messages = queue.get(:n => 7) # => [#<IronMQ::Message:...>, ...]
+messages = queue.reserve(n: 7) # => [#<IronMQ::Message:...>, ...]
 
 # or message by ID
-message = queue.get "5127bf043264140e863e2283" # => #<IronMQ::Message:...>
+message = queue.get_message '5127bf043264140e863e2283'
+# => #<IronMQ::Message:...>
 ```
 
 **Optional parameters:**
 
 * `n`: The maximum number of messages to get. Default is 1. Maximum is 100.
-
 * `timeout`: After timeout (in seconds), item will be placed back onto queue.
 You must delete the message from the queue to ensure it does not go back onto the queue.
 If not set, value from POST is used. Default is 60 seconds. Minimum is 30 seconds.
 Maximum is 86,400 seconds (24 hours).
+* `wait`: : Time in seconds to wait for a message to become available. This enables long polling. Default is 0 (does not wait), maximum is 30.
+* `delete`: true/false. This will delete the message on get. Be careful though, only use this if you are ok with losing a message if something goes wrong after you get it. Default is false.
 
 When `n` parameter is specified and greater than 1 method returns `Array` of `Message`s.
 Otherwise, `Message` object would be returned.
@@ -248,7 +411,7 @@ Otherwise, `Message` object would be returned.
 Touching a reserved message extends its timeout by the duration specified when the message was created, which is 60 seconds by default.
 
 ```ruby
-message = queue.get # => #<IronMQ::Message:...>
+message = queue.reserve # => #<IronMQ::Message:...>
 
 message.touch # => #<IronMQ::ResponseBase:...>
 ```
@@ -258,11 +421,11 @@ message.touch # => #<IronMQ::ResponseBase:...>
 ### Release Message
 
 ```ruby
-message = queue.get # => #<IronMQ::Message:...>
+message = queue.reserve # => #<IronMQ::Message:...>
 
 response = message.release # => #<IronMQ::ResponseBase:...>
 # or
-response = message.release(:delay => 42) # => #<IronMQ::ResponseBase:...>
+response = message.release(delay: 42) # => #<IronMQ::ResponseBase:...>
 ```
 
 **Optional parameters:**
@@ -275,7 +438,7 @@ Default is 0 seconds. Maximum is 604,800 seconds (7 days).
 ### Delete a Message from a Queue
 
 ```ruby
-message = queue.get # => #<IronMQ::Queue:...>
+message = queue.reserve # => #<IronMQ::Queue:...>
 
 message.delete # => #<IronMQ::ResponseBase:...>
 ```
@@ -289,7 +452,8 @@ Peeking at a queue returns the next messages on the queue, but it does not reser
 ```ruby
 message = queue.peek # => #<IronMQ::Message:...>
 # or multiple messages
-messages = queue.peek(:n => 13) # => [#<IronMQ::Message:...>, ...]
+messages = queue.peek(n: 13)
+# => [#<IronMQ::Message:...>, ...]
 ```
 
 **Optional parameters:**
@@ -313,6 +477,36 @@ Polling will automatically delete the message at the end of the block.
 ```ruby
 queue.clear # => #<IronMQ::ResponseBase:...>
 ```
+### Add an Alert to a Queue
+
+[Check out our Blog Post on Queue Alerts](http://blog.iron.io).
+
+Alerts have now been incorporated into IronMQ. This feature lets developers control actions based on the activity within a queue. With alerts, actions can be triggered when the number of messages in a queue reach a certain threshold. These actions can include things like auto-scaling, failure detection, load-monitoring, and system health.
+
+You may add up to 5 alerts per queue.
+
+**Required parameters:**
+* `type`: required - "fixed" or "progressive". In case of alert's type set to "fixed", alert will be triggered when queue size pass value set by trigger parameter. When type set to "progressive", alert will be triggered when queue size pass any of values, calculated by trigger * N where N >= 1. For example, if trigger set to 10, alert will be triggered at queue sizes 10, 20, 30, etc.
+* `direction`: required - "asc" or "desc". Set direction in which queue size must be changed when pass trigger value. If direction set to "asc" queue size must growing to trigger alert. When direction is "desc" queue size must decreasing to trigger alert.
+* `trigger`: required. It will be used to calculate actual values of queue size when alert must be triggered. See type field description. Trigger must be integer value greater than 0.
+* `queue`: required. Name of queue which will be used to post alert messages.
+
+**Optional parameters:**
+
+* `snooze`: Number of seconds between alerts. If alert must be triggered but snooze is still active, alert will be omitted. Snooze must be integer value greater than or equal to 0.
+
+```ruby
+queue.add_alert({
+                  type: 'progressive',
+                  trigger: 10,
+                  queue: 'my_alert_queue',
+                  direction: 'asc',
+                  snooze: 0
+                })
+queue.clear
+# => #<IronMQ::ResponseBase:0x007f95d3b25438 @raw={"msg"=>"Updated"}, @code=200>
+```
+
 
 --
 
@@ -325,36 +519,65 @@ IronMQ push queues allow you to setup a queue that will push to an endpoint, rat
 ### Update a Message Queue
 
 ```ruby
-queue_info = queue.update(options) # => {"id"=>"5127bf043264140e863e2283", "name"=>"my_queue", ...}
+options = {
+  message_timeout: 120,
+  message_expiration: 24 * 3600,
+  push: {
+    subscribers: [
+      {
+        name: 'subscriber_name',
+        url: 'http://rest-test.iron.io/code/200?store=key1',
+        headers: {
+          'Content-Type' => 'application/json'
+        }
+      }
+    ],
+    retries: 3,
+    retries_delay: 30,
+    error_queue: 'error_queue_name'
+  }
+}
+
+queue.update(options)
 ```
 
 **The following parameters are all related to Push Queues:**
 
-* `subscribers`: An array of subscriber hashes containing a “url” field.
+* `push: subscribers`: An array of subscriber hashes containing a `name` and a `url` required fields,
+and optional `headers` hash. `headers`'s keys are names and values are means of HTTP headers.
 This set of subscribers will replace the existing subscribers.
 To add or remove subscribers, see the add subscribers endpoint or the remove subscribers endpoint.
 See below for example json.
-* `push_type`: Either `multicast` to push to all subscribers or `unicast` to push to one and only one subscriber. Default is `multicast`.
-* `retries`: How many times to retry on failure. Default is 3. Maximum is 100.
-* `retries_delay`: Delay between each retry in seconds. Default is 60.
+* `push: retries`: How many times to retry on failure. Default is 3. Maximum is 100.
+* `push: retries_delay`: Delay between each retry in seconds. Default is 60.
+* `push: error_queue`: String. Queue name to post push errors to.
+
+**Note:** queue type cannot be changed.
 
 --
 
 ### Set Subscribers on a Queue
 
-Subscribers can be any HTTP endpoint. `push_type` is one of:
+Subscribers can be any HTTP endpoint. push `type` is one of:
 
 * `multicast`: will push to all endpoints/subscribers
 * `unicast`: will push to one and only one endpoint/subscriber
 
 ```ruby
-ptype = :multicast
-subscribers = [
-  {:url => "http://rest-test.iron.io/code/200?store=key1"},
-  {:url => "http://rest-test.iron.io/code/200?store=key2"}
-]
-
-queue.update(:subscribers => subscribers, :push_type => ptype)
+ironmq = IronMQ::Client.new
+subscribers =
+  [
+   {
+     name: 'key-one-sub',
+     url: 'http://rest-test.iron.io/code/200?store=key1'
+   },
+   {
+     name: 'key-two-sub',
+     url: 'http://rest-test.iron.io/code/200?store=key2'
+   }
+  ]
+ironmq.create_queue('queue_name', type: :multicast,
+                    push: {subscribers: subscribers})
 ```
 
 --
@@ -362,20 +585,26 @@ queue.update(:subscribers => subscribers, :push_type => ptype)
 ### Add/Remove Subscribers on a Queue
 
 ```ruby
-queue.add_subscriber({:url => "http://nowhere.com"})
+queue.add_subscriber({
+                       name: 'nowhere',
+                       url: 'http://nowhere.com/push'
+                     })
 
 queue.add_subscribers([
-  {:url => 'http://first.endpoint.xx/process'},
-  {:url => 'http://second.endpoint.xx/process'}
-])
-
-
-queue.remove_subscriber({url: "http://nowhere.com"})
-
-queue.remove_subscribers([
-  {:url => 'http://first.endpoint.xx/process'},
-  {:url => 'http://second.endpoint.xx/process'}
-])
+                       {
+                         name: 'first',
+                         url: 'http://first.endpoint.xx/process',
+                         headers: {
+                           'Content-Type': 'application/json'
+                         }
+                       },
+                       {
+                         name: 'second',
+                         url: 'http://second.endpoint.xx/process'
+                       }
+                      ])
+
+queue.clear_subscribers
 ```
 
 --
@@ -387,9 +616,11 @@ instead getting it by ID returned in API response. To do this just set `:instant
 to `true`.
 
 ```ruby
-message = queue.post('push me!', :instantiate => true) # => #<IronMQ::Message:...>
+message = queue.post('push me!', instantiate: true)
+# => #<IronMQ::Message:...>
 
-msgs = queue([{:body => 'push'}, {:body => 'me'}], :instantiate => true) # => [#<IronMQ::Message:...>, ...]
+msgs = queue.post([{body: 'push'}, {body: 'me'}], instantiate: true)
+# => [#<IronMQ::Message:...>, ...]
 ```
 
 This creates fake `Message` objects. They contain only IDs.
@@ -401,9 +632,12 @@ This creates fake `Message` objects. They contain only IDs.
 After pushing a message:
 
 ```ruby
-subscribers = queue.get(msg.id).subscribers # => [#<IronMQ::Subscriber:...>, ...]
+statuses = queue.get_message(msg.id).push_statuses
+# => [#<IronMQ::Subscriber:...>, ...]
 
-subscribers.each { |ss| puts "#{ss.id}: #{(ss.code == 200) ? 'Success' : 'Fail'}" }
+statuses.each do |s|
+  puts "#{s.subscriber_name}: #{(s.code == 200) ? 'Success' : 'Fail'}"
+end
 ```
 
 Returns an array of subscribers with status.
@@ -416,26 +650,142 @@ This creates fake `IronMQ::Message` instance on which you call for subscribers'
 ### Acknowledge / Delete Message Push Status
 
 ```ruby
-subscribers = queue.get(msg.id).subscribers # => [#<IronMQ::Subscriber:...>, ...]
+subscribers = queue.get_message(msg.id).subscribers
+# => [#<IronMQ::Subscriber:...>, ...]
 
 subscribers.each do |ss|
   ss.delete
-  # ss.acknowledge # This is `delete` alias
+  # ss.acknowledge # This is `delete`'s alias
 end
 ```
 
 --
 
-### Revert Queue Back to Pull Queue
+## Queue Alerts
+
+Queue Alerts allow you to set queue's size levels which are critical
+for your application. For example, you want to start processing worker
+when queue size grows from 0 to 1. Then add alert of `type` "fixed",
+`direction` "asc", and `trigger` 1. In this case, if queue size changed
+from 0 to 1 alert message will be put on queue, set by `queue`
+parameter of alert's hash. If you want to prevent alerts to be put onto
+alert queue in some time after previous alert message - use `snooze`
+parameter. For example, to make alert silent in one hour, set `snooze`
+to 3600 (seconds).
+
+**Note:** alerts feature are only avalable for Pull (or regular) Queues.
+
+See [Queue Alerts](http://dev.iron.io/mq/reference/queue_alerts/) to learn more.
+
+### Alerts Parameters
+
+Alerts can be configured with the following parameters:
+
+* `type`: string, required. Type of alert. Available types are "fixed"
+  and "progressive".
+* `direction`: string, optional. Direction of queue fluctuations.
+  Available directions are "asc" (alert will be triggered if queue
+  size grows) and "desc" (alert will be triggered if queue size
+  decreases). Defaults to "asc".
+* `trigger`: integer, required. Value which is used to calculate
+  actual queue size when alert will be triggered. In case of "fixed"
+  type of alert `trigger` itself represents actual queue size. When
+  type of alert is "progressive", actual queue sizes are calculated by
+  `trigger * N`, where `N` is integer greater than 0. For example,
+  type is "progressive" and trigger is 100. Alert messages will be put
+  on queue at sizes 100, 200, 300, ...
+* `queue`: string, required. Name of a queue which receives alert messages.
+* `snooze`: integer, optional. Represents number of seconds alert will
+  be silent after latter message, put onto alert queue.
 
-If you want to revert you queue just update `push_type` to `'pull'`.
+**Note:** IronMQ backend checks for alerts duplications each time you
+  add new alerts to a queue. It compares `type`, `direction`, and
+  `trigger` parameters to find duplicates. If one or more of new
+  alerts duplicates existing, backend return `HTTP 400` error, message
+  will be `{"msg": "At least one new alert duplicates current queue alerts."}`.
+
+### Add Alerts to a Queue
+
+To add single alert to a queue.
 
 ```ruby
-queue.update(:push_type => 'pull');
+queue.add_alert({
+                  type: 'fixed',
+                  direction: 'asc',
+                  trigger: 1,
+                  queue: 'alerts-queue',
+                  snooze: 600
+                })
+# => #<IronMQ::ResponseBase:0x007f8d22980420 @raw={"msg"=>"Alerts were added."}, @code=200>
 ```
 
---
+To add multiple alerts at a time.
+
+```ruby
+queue.add_alerts([
+                  {
+                    type: 'fixed',
+                    direction: 'desc',
+                    trigger: 1,
+                    queue: 'alerts-queue'
+                  },
+                  {
+                    type: 'progressive',
+                    trigger: 1000,
+                    queue: 'critical-alerts-queue'
+                  }
+                 ])
+# => #<IronMQ::ResponseBase:0x00abcdf1980420 @raw={"msg"=>"Alerts were added."}, @code=200>
+```
+
+### Remove Alerts from a Queue
+
+To remove single alert by its ID.
+
+```ruby
+queue.remove_alert({ id: '5eee546df4a4140e8638a7e5' })
+# => #<IronMQ::ResponseBase:0x007f8d229a1878 @raw={"msg"=>"Alerts were deleted."}, @code=200>
+```
+
+Remove multiple alerts by IDs.
+
+```ruby
+queue.remove_alerts([
+  { id: '53060b541185ab3eaf04c83f' },
+  { id: '99a50b541185ab3eaf9bcfff' }
+])
+# => #<IronMQ::ResponseBase:0x093b8d229a18af @raw={"msg"=>"Alerts were deleted."}, @code=200>
+```
+
+### Replace and Clear Alerts on a Queue
+
+Following code sample shows how to replace alerts on a queue.
+
+```ruby
+queue.replace_alerts([
+                      {
+                        type: 'fixed',
+                        trigger: 100,
+                        queue: 'alerts'
+                      }
+                     ])
+# => #<IronMQ::ResponseBase:0x00008d229a16bf @raw={"msg"=>"Alerts were replaced."}, @code=200>
+```
+
+To clear alerts on a queue.
+
+```ruby
+queue.clear_alerts
+# => #<IronMQ::ResponseBase:0x87ad13ff3a18af @raw={"msg"=>"Alerts were replaced."}, @code=200>
+```
+
+**Note:** `Queue#clear_alerts` is a helper, which represents
+  `Queue#replace_alerts` call with empty `Array` of alerts.
+
+## Important Notes
 
+* [Ruby 1.8 is no more supported](https://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+* Queue type is static now. Once it is set, it cannot be changed.
 
 ## Further Links