restful_metrics 1.1.5 → 2.0.0.pre.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a87120f361df0b33c22f49d2a2706bfc5e4db523
-  data.tar.gz: dde139c1af427a6e76680bda29578cf3e8fdc0c4
+  metadata.gz: 84feeac72efa68de2b75d957db08b0a5de75f867
+  data.tar.gz: 05b3a6939decc3c2803057e8b41853405bbeb5d1
 SHA512:
-  metadata.gz: 78ecbc502a47d8532acc9baa75681615745342760dd436fde052f904a1f5bb8a91240c3d392ccfb7569acbff062746c99f2c9b81678d09d9204c16763ab1072a
-  data.tar.gz: 49dc2a581bda4b66ca5e25c4063ad6d33bb109523833f4f0282f3f083dd5834864dfa21f9781f5fe9e23f0c6a9933c28c612314a10826add3e7b210167528d1b
+  metadata.gz: 25d9d091c84f1ea4a41b2e99e6de605e665a352f94f9aacc7eadd33d325627a4580b17cec8984795958f9cde9636db0f5d1941351cc7ad838e6b8fcc97f72da9
+  data.tar.gz: fc89d8d3578c1eebfdd682988834cf467fe0587ea47e21119796537e1b05dfb6e79849f68ad9a900ce6020880b010f7b9b6422a2adb6c94aadfd17aa31ba38c5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    restful_metrics (1.1.5)
+    restful_metrics (2.0.0.pre.alpha.1)
       rest-client (~> 1.6.0)
       yajl-ruby (>= 0.8.1)
 
@@ -25,8 +25,6 @@ GEM
       i18n (~> 0.5.0)
     activesupport (3.0.11)
     builder (2.1.2)
-    delayed_job (3.0.1)
-      activesupport (~> 3.0)
     diff-lcs (1.1.3)
     erubis (2.6.6)
       abstract (>= 1.0.0)
@@ -63,7 +61,6 @@ PLATFORMS
 DEPENDENCIES
   actionpack (~> 3.0.0)
   activesupport (~> 3.0.0)
-  delayed_job (~> 3.0.1)
   mocha (~> 0.10.4)
   rack (~> 1.2.5)
   restful_metrics!

data/README.md

@@ -6,10 +6,10 @@ For more detailed instructions, check out our [Dev Center](http://devcenter.rest
 
 ## Install
 
-* Version 1.x of this client is deprecated. Please switch to 2.x *
+* Please note the syntax for version 2.x of the Ruby client has changed. *
 
 ```
-  gem install restful_metrics-ruby
+  gem install restful_metrics
 ```
 
 ## Configure
@@ -22,8 +22,6 @@ The only step required for initialization is setting your API key. Once it's set
   RestfulMetrics::Client.set_credentials('214c7da8edd333abc78712313918ffe5')
 ```
 
-You can skip this step if you've installed the RESTful Metrics Heroku Addon.
-
 ### Disable Flag
 
 The client also has an optional flag that prevents the client from actually sending data points to the server. This allows you to keep your RESTful Metrics tracking code in place even in your test enviornments. You can disable the client with the following (by default the client is enabled):
@@ -34,36 +32,34 @@ The client also has an optional flag that prevents the client from actually send
 
 We added the optional conditional check in the above example to illustrate how the flag can be set dynamically during your application's launch.
 
-### Asynchronous Mode
-
-The client currently has built-in support for Delayed::Job. If you enable the asynchronous flag the client will automatically queue the data point for transmission to the server at a later time. This is highly recommended for applications that are sensitive to latency.
+### Asynchronous Transmission
 
-``` ruby
-  RestfulMetrics::Client.async = true
-```
+You can wrap all your RESTful Metrics calls with Delayed::Job / Resque / Sidekiq, etc.
 
-If you use a worker library other than Delayed::Job, you can wrap all your RESTful Metrics calls. For example, if we were using Resque we might add this to an initializer:
+For example:
 
 ``` ruby
   module CompoundMetric
     @queue = :metrics
 
-    def self.perform(fqdn, name, values, distinct_id = nil)
-      RestfulMetrics::Client.add_compound_metric(fqdn, name, values, distinct_id)
+    def self.perform(fqdn, name, values, timestamp=nil, distinct_id=nil)
+      RestfulMetrics::Client.add_compound_metric :app => fqdn,
+                                                 :name => name,
+                                                 :values => values,
+                                                 :occurred_at => timestamp,
+                                                 :distinct_id => distinct_id
     end
   end
 
   module Metric
     @queue = :metrics
 
-    def self.perform(fqdn, name, value, distinct_id = nil)
-      RestfulMetrics::Client.add_metric(fqdn, name, value, distinct_id)
-    end
-  end
-
-  def restful_metrics_add_data_point(metric_type, app, metric, value, distinct_id=nil)
-    unless RestfulMetrics::Client.disabled?
-      Resque.enqueue(metric_type, app, metric, value, distinct_id)
+    def self.perform(fqdn, name, value, timestamp=nil, distinct_id=nil)
+      RestfulMetrics::Client.add_metric :app => fqdn,
+                                        :name => name,
+                                        :value => value,
+                                        :occurred_at => timestamp,
+                                        :distinct_id => distinct_id
     end
   end
 ```
@@ -71,11 +67,13 @@ If you use a worker library other than Delayed::Job, you can wrap all your RESTf
 We've now separated the metrics and compound metrics into their own queue called `metrics`. To add a compound metric data point, we call:
 
 ``` ruby
-    restful_metrics_add_data_point(CompoundMetric, "myapp.com", "impression", ["apple juice", "orange juice", "soda"], "fe352fe23e823668e23e7")
+    Resque.enqueue CompoundMetric, :app => 'myapp.com',
+                                   :name => 'impression',
+                                   :values => ['apple juice', 'orange juice', 'soda'],
+                                   :occurred_at => Time.now,
+                                   :distinct_id => user.uuid
 ```
 
-Make sure that the `async` flag is set to off. This flag only applies to the built-in Delayed::Job support.
-
 ## Sending Data Points
 
 ### Metrics
@@ -87,12 +85,13 @@ Attribute                 | Value
 Application Identifier    | "myapp.com"
 Metric Name               | "impression"
 Value                     | 1
+Occurred At               | Time or DateTime object
 Distinct User Identifier  | "fe352fe23e823668e23e7"
 
 You would transmit this data point with the following:
 
 ``` ruby
-  RestfulMetrics::Client.add_metric("myapp.com", "impression", 1, "fe352fe23e823668e23e7")
+  RestfulMetrics::Client.add_metric(:app => "myapp.com", :name => "impression", :value => 1, :occurred_at => Time.now, :distinct_id => "fe352fe23e823668e23e7")
 ```
 
 ### Compound Metrics
@@ -104,12 +103,13 @@ Attribute                 | Value
 Application Identifier    | "myapp.com"
 Compound Metric Name      | "beverage_search"
 Values                    | ["apple juice", "orange juice", "soda"]
+Occurred At               | Time or DateTime object
 Distinct User Identifier  | "fe352fe23e823668e23e7"
 
 You would transmit this data point with the following:
 
 ``` ruby
-  RestfulMetrics::Client.add_compound_metric("myapp.com", "impression", ["apple juice", "orange juice", "soda"], "fe352fe23e823668e23e7")
+  RestfulMetrics::Client.add_compound_metric(:app => "myapp.com", :name => "impression", :values => ["apple juice", "orange juice", "soda"], :occurred_at => Time.now, :distinct_id => "fe352fe23e823668e23e7")
 ```
 
 ## Copyright

data/VERSION

@@ -1 +1 @@
-1.1.5
+2.0.0-alpha.1

data/lib/restful_metrics/client.rb

@@ -5,7 +5,7 @@ module RestfulMetrics
     extend LogTools
 
     @@connection = nil
-    @@debug, @@async, @@disabled = false
+    @@debug, @@disabled = false
 
     class << self
 
@@ -24,18 +24,6 @@ module RestfulMetrics
         @@debug
       end
 
-      def async=(async_flag)
-        # DelayedJob integration
-        require 'delayed_job' if async_flag
-
-        @@async = async_flag && (defined?(Delayed) != nil)
-        @@connection.async = @@async if @@connection
-      end
-
-      def async?
-        @@async
-      end
-
       def disabled=(disabled_flag)
         @@disabled = disabled_flag
       end
@@ -44,27 +32,48 @@ module RestfulMetrics
         @@disabled
       end
 
-      def add_metric(fqdn, name, value, distinct_id = nil)
+      def add_metric(*args)
+        options = extract_options!(args)
+
         params = Hash.new
         params[:metric] = Hash.new
-        params[:metric][:fqdn] = fqdn
-        params[:metric][:name] = name
-        params[:metric][:value] = value
-        unless distinct_id.nil?
-          params[:metric][:distinct_id] = distinct_id
+        params[:metric][:fqdn] = options[:app]
+        params[:metric][:name] = options[:name]
+        params[:metric][:value] = options[:value]
+
+        unless options[:distinct_id].nil?
+          params[:metric][:distinct_id] = options[:distinct_id]
+        end
+
+        if options[:occurred_at].nil?
+          params[:metric][:occurred_at] = Time.now.to_i
+        else
+
+          raise InvalidTimestamp unless options[:occurred_at].respond_to?(:to_i)
+          params[:metric][:occurred_at] = options[:occurred_at].to_i
         end
 
         post(Endpoint.metrics, params)
       end
 
-      def add_compound_metric(fqdn, name, values, distinct_id = nil)
+      def add_compound_metric(*args)
+        options = extract_options!(args)
+
         params = Hash.new
         params[:compound_metric] = Hash.new
-        params[:compound_metric][:fqdn] = fqdn
-        params[:compound_metric][:name] = name
-        params[:compound_metric][:values] = values
-        unless distinct_id.nil?
-          params[:compound_metric][:distinct_id] = distinct_id
+        params[:compound_metric][:fqdn] = options[:app]
+        params[:compound_metric][:name] = options[:name]
+        params[:compound_metric][:values] = options[:values]
+
+        unless options[:distinct_id].nil?
+          params[:compound_metric][:distinct_id] = options[:distinct_id]
+        end
+
+        params[:compound_metric][:occurred_at] = if options[:occurred_at].nil?
+          Time.now.to_i
+        else
+          raise InvalidTimestamp unless options[:occurred_at].respond_to?(:to_i)
+          options[:occurred_at].to_i
         end
 
         post(Endpoint.compound_metrics, params)
@@ -80,12 +89,7 @@ module RestfulMetrics
 
         raise NoConnectionEstablished if @@connection.nil?
 
-        if async?
-          self.delay.transmit(endpoint, data)
-          true
-        else
-          transmit(endpoint, data)
-        end
+        transmit(endpoint, data)
       end
 
       def transmit(endpoint, data)

data/lib/restful_metrics/connection.rb

@@ -55,12 +55,12 @@ module RestfulMetrics
         if response.nil?
           logger "There was an error processing the response from Restful Metrics."
         else
-          logger "\nresponse: #{response.code}"
-          logger "headers:"
-          response.header.each do |key, value|
+          logger "Response Code: #{response.code}"
+          logger "Response Headers:"
+          response.headers.each do |key, value|
             logger "#{key}=#{value}"
           end
-          logger "body:"
+          logger "Body:"
           logger response.body
         end
       end

data/lib/restful_metrics.rb

@@ -24,5 +24,6 @@ module RestfulMetrics
   class InsufficentArguments < RestfulMetricsError; end
   class InvalidAPIKey < RestfulMetricsError; end
   class NoConnectionEstablished < RestfulMetricsError; end
-  
+  class InvalidTimestamp < RestfulMetricsError; end
+
 end

data/restful_metrics.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "actionpack", "~> 3.0.0"
   s.add_development_dependency "rack", "~> 1.2.5"
   s.add_development_dependency "activesupport", "~> 3.0.0"
-  s.add_development_dependency "delayed_job", "~> 3.0.1"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/client_spec.rb

@@ -4,13 +4,13 @@ describe "A NON-initialized RESTful Metrics client" do
 
   it "should NOT send a metric data point" do
     lambda {
-      RestfulMetrics::Client.add_metric("foo.bar.org", "hit", 1)
+      RestfulMetrics::Client.add_metric(:app => "foo.bar.org", :name => "hit", :value => 1)
     }.should raise_error(RestfulMetrics::NoConnectionEstablished)
   end
 
   it "should NOT send a compound metric data point" do
     lambda {
-      RestfulMetrics::Client.add_compound_metric("foo.bar.org", "hit", [1,2,3])
+      RestfulMetrics::Client.add_compound_metric(:app => "foo.bar.org", :name => "hit", :values => [1,2,3])
     }.should raise_error(RestfulMetrics::NoConnectionEstablished)
   end
 
@@ -23,13 +23,13 @@ describe "A NON-initialized RESTful Metrics client" do
 
     it "should NOT send a metric data point" do
       lambda {
-        RestfulMetrics::Client.add_metric("foo.bar.org", "hit", 1).should be_true
+        RestfulMetrics::Client.add_metric(:app => "foo.bar.org", :name => "hit", :value => 1).should be_true
       }.should raise_error(RestfulMetrics::NoConnectionEstablished)
     end
 
     it "should NOT send a compound metric data point" do
       lambda {
-        RestfulMetrics::Client.add_compound_metric("foo.bar.org", "hit", [1,2,3]).should be_true
+        RestfulMetrics::Client.add_compound_metric(:app => "foo.bar.org", :name => "hit", :values => [1,2,3]).should be_true
       }.should raise_error(RestfulMetrics::NoConnectionEstablished)
     end
 
@@ -49,12 +49,12 @@ describe "A disabled RESTful Metrics client" do
 
   it "should NOT send a metric if the client is in disabled-mode" do
     RestfulMetrics::Client.expects(:transmit).never
-    RestfulMetrics::Client.add_metric("foo.bar.org", "hit", 1).should == false
+    RestfulMetrics::Client.add_metric(:app => "foo.bar.org", :name => "hit", :value => 1).should == false
   end
 
   it "should NOT send a compound metric if the client is in disabled-mode" do
     RestfulMetrics::Client.expects(:transmit).never
-    RestfulMetrics::Client.add_compound_metric("foo.bar.org", "hit", [1,2,3]).should == false
+    RestfulMetrics::Client.add_compound_metric(:app => "foo.bar.org", :name => "hit", :values => [1,2,3]).should == false
   end
 
 end
@@ -71,7 +71,7 @@ describe "An initialized RESTful Metrics client" do
       200
     end
 
-    def header
+    def headers
       { "one" => "test", "two" => "test" }
     end
 
@@ -83,7 +83,6 @@ describe "An initialized RESTful Metrics client" do
     RestfulMetrics::Client.disabled = false
     RestClient::Request.any_instance.stubs(:execute).returns(SampleRequest.new)
     Logger.any_instance.stubs(:warn).returns("") # disable output
-    Delayed::Job.delete_all
   end
 
   describe "in debug mode" do
@@ -95,11 +94,11 @@ describe "An initialized RESTful Metrics client" do
     end
 
     it "should send a metric to RESTful Metrics while outputting debug info" do
-      RestfulMetrics::Client.add_metric("foo.bar.org", "hit", 1).should be_true
+      RestfulMetrics::Client.add_metric(:app => "foo.bar.org", :name => "hit", :value => 1).should be_true
     end
 
     it "should send the compound metric to RESTful Metrics while outputting debug info" do
-      RestfulMetrics::Client.add_compound_metric("foo.bar.org", "hit", [1,2,3]).should be_true
+      RestfulMetrics::Client.add_compound_metric(:app => "foo.bar.org", :name => "hit", :values => [1,2,3]).should be_true
     end
 
   end
@@ -110,45 +109,73 @@ describe "An initialized RESTful Metrics client" do
       RestfulMetrics::Client.set_credentials('4ed4ef44e44ed4').should be_true
     end
 
-    it "should set async mode when delayed_job is loaded" do
-      RestfulMetrics::Client.async = true
-      RestfulMetrics::Client.async?.should be_true
-    end
-
   end
 
-  describe "adding metrics synchronously" do
-
-    before(:all) do
-      RestfulMetrics::Client.async = false
-      RestfulMetrics::Client.async?.should be_false
-    end
-
+  describe "adding metrics" do
     it "should send the metric to RESTful Metrics" do
-      RestfulMetrics::Client.add_metric("foo.bar.org", "hit", 1).should be_true
+      RestfulMetrics::Client.add_metric(:app => "foo.bar.org", :name => "hit", :value => 1, :occurred_at => Time.now).should be_true
     end
 
     it "should send the compound metric to RESTful Metrics" do
-      RestfulMetrics::Client.add_compound_metric("foo.bar.org", "hit", [1,2,3]).should be_true
+      RestfulMetrics::Client.add_compound_metric(:app => "foo.bar.org", :name => "hit", :values => [1,2,3], :occurred_at => Time.now).should be_true
     end
 
   end
 
-  describe "adding metrics asynchronously" do
+  describe '#add_metric' do
+    let(:params) {
+      p = {:app => "foo.bar.org", :name => "hit", :value => 1}
+      p[:occurred_at] = occurred_at unless occurred_at.blank?
+      p
+    }
 
-    before(:all) do
-      RestfulMetrics::Client.async = true
-      RestfulMetrics::Client.async?.should be_true
+    context 'when :occurred_at is blank' do
+      let(:occurred_at) { nil }
+
+      it 'fills in the current time' do
+        #TODO: Use the same parameter names everywhere. Move translations out to the boundary of our system.
+        params_with_timestamp = { :metric => params.merge(:occurred_at => Time.now.to_i) }
+        params_with_timestamp[:metric][:fqdn] = params_with_timestamp[:metric].delete(:app)
+
+        RestfulMetrics::Client.expects(:post).with(RestfulMetrics::Endpoint.metrics, params_with_timestamp)
+        RestfulMetrics::Client.add_metric(params)
+      end
     end
+  end
 
-    it "should create a delayed job for the metric" do
-      RestfulMetrics::Client.add_metric("foo.bar.org", "hit", 1).should be_true
-      Delayed::Job.count.should == 1
+  describe '#add_compound_metric' do
+    let(:params) {
+      p = {:app => "foo.bar.org", :name => "hit", :values => [1, 2, 3]}
+      p[:occurred_at] = occurred_at unless occurred_at.blank?
+      p
+    }
+
+    context 'when :occurred_at is blank' do
+      let(:occurred_at) { nil }
+
+      it 'fills in the current time' do
+        #TODO: Use the same parameter names everywhere. Move translations out to the boundary of our system.
+        params_with_timestamp = { :compound_metric => params.merge(:occurred_at => Time.now.to_i) }
+        params_with_timestamp[:compound_metric][:fqdn] = params_with_timestamp[:compound_metric].delete(:app)
+
+        RestfulMetrics::Client.expects(:post).with(RestfulMetrics::Endpoint.compound_metrics, params_with_timestamp)
+        RestfulMetrics::Client.add_compound_metric(params)
+      end
     end
+  end
+
+  describe "raising errors" do
 
-    it "should create a delayed job for the compound metric" do
-      RestfulMetrics::Client.add_compound_metric("foo.bar.org", "hit", [1,2,3]).should be_true
-      Delayed::Job.count.should == 1
+    it "should NOT accept an invalid occurred_at timestamp when sending metrics" do
+      lambda {
+        RestfulMetrics::Client.add_metric(:app => "foo.bar.org", :name => "hit", :value => 1, :occurred_at => Date.today)
+      }.should raise_error(RestfulMetrics::InvalidTimestamp)
+    end
+
+    it "should NOT accept an invalid occurred_at timestamp when sending compound metrics" do
+      lambda {
+        RestfulMetrics::Client.add_compound_metric(:app => "foo.bar.org", :name => "hit", :values => [1,2,3], :occurred_at => Date.today).should be_false
+      }.should raise_error(RestfulMetrics::InvalidTimestamp)
     end
 
   end

data/spec/cookie_integration_spec.rb

@@ -2,43 +2,79 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Rails controller integration" do
 
-  class ApplicationController < ActionController::Base
+  class TestController
+    include RestfulMetrics::ControllerMethods::InstanceMethods
 
-    before_filter :track_impression
-
-    private
+    def cookies
+      @cookies ||= {}
+    end
 
-      def track_impression
-        RestfulMetrics::Client.add_metric("foo.bar.org", "impression", 1, restful_metrics_cookie)
-      end
+    def request
+      require 'ostruct'
 
+      struct = OpenStruct.new
+      struct.host = 'foo.com'
+      struct
+    end
   end
 
-  class TestController < ApplicationController
+  let(:test_controller) { TestController.new }
+
+  describe '#restful_metrics_cookie' do
+    let(:result) { test_controller.send(:restful_metrics_cookie) }
 
-    def index
-      @distinct_id = restful_metrics_cookie
-      RestfulMetrics::Client.add_metric("foo.bar.org", "custom", 1, @distinct_id)
-      render :text => "OK"
+    it 'generates a distinct id' do
+      test_controller.expects(:generate_distinct_id).once
+      result
     end
 
-    def rescue_action(e); raise(e); end
-  end
+    it 'sets the :restful_metrics cookie' do
+      result
+      test_controller.cookies[:restful_metrics].should be_present
+    end
 
-  before(:each) do
-    ActionDispatch::Request.any_instance.stubs(:cookie_jar).returns({})
-    RestfulMetrics::Connection.any_instance.stubs(:post).returns(true)
-    RestfulMetrics::Client.set_credentials('xyz123')
-  end
+    context 'when the :analytico cookie exists' do
+      let(:existing_cookie) { '1234123412341234' }
+
+      before do
+        test_controller.cookies[:analytico] = existing_cookie
+      end
+
+      it 'returns the existing cookie' do
+        result.should == existing_cookie
+      end
+    end
 
-  it "should track all metrics in the stack" do
-    RestfulMetrics::Client.expects(:add_metric).twice.returns(true)
+    context 'when the :restful_metrics cookie exists' do
+      let(:existing_cookie) { '897123408971234' }
 
-    env = Rack::MockRequest.env_for('/', :params => {'id' => '1'})
-    status, headers, body = TestController.action(:index).call(env)
-    @response = ActionDispatch::TestResponse.new(status, headers, body)
+      before do
+        test_controller.cookies[:restful_metrics] = existing_cookie
+      end
 
-    @response.code.should == "200"
+      it 'returns the existing cookie' do
+        result.should == existing_cookie
+      end
+    end
   end
 
+  describe '#generate_distinct_id' do
+    let(:test_controller) { TestController.new }
+    let(:result) { test_controller.send(:generate_distinct_id) }
+
+    it 'returns a string' do
+      result.class.should == String
+    end
+
+    it 'returns 32 characters' do
+      result.length.should == 32
+    end
+
+    it 'returns unique ids' do
+      ids = 100.times.collect { test_controller.send(:generate_distinct_id) }
+      unique_ids = ids.sort.uniq
+
+      ids.length.should == unique_ids.length
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -13,8 +13,6 @@ require 'rspec'
 require 'mocha'
 require 'restful_metrics'
 
-require 'delayed_job'
-
 include Rack::Test::Methods
 
 # Requires supporting files with custom matchers and macros, etc,
@@ -24,5 +22,3 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 RSpec.configure do |config|
   config.mock_framework = :mocha
 end
-
-Delayed::Worker.backend = :mock

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restful_metrics
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 2.0.0.pre.alpha.1
 platform: ruby
 authors:
 - Mauricio Gomes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
@@ -109,20 +109,6 @@ dependencies:
         version: 3.0.0
   prerelease: false
   name: activesupport
-- !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.0.1
-  type: :development
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.0.1
-  prerelease: false
-  name: delayed_job
 description: Ruby client for the RESTful Metrics service.
 email: mauricio@restful-labs.com
 executables: []
@@ -147,8 +133,6 @@ files:
 - restful_metrics.gemspec
 - spec/client_spec.rb
 - spec/cookie_integration_spec.rb
-- spec/delayed/backend/mock.rb
-- spec/delayed/serialization/mock.rb
 - spec/endpoint_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/restful-labs/resetful_metrics-ruby
@@ -165,9 +149,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5
@@ -177,8 +161,6 @@ summary: Ruby client for the RESTful Metrics service.
 test_files:
 - spec/client_spec.rb
 - spec/cookie_integration_spec.rb
-- spec/delayed/backend/mock.rb
-- spec/delayed/serialization/mock.rb
 - spec/endpoint_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/delayed/backend/mock.rb

@@ -1,112 +0,0 @@
-require 'ostruct'
-
-# An in-memory backend suitable only for testing. Tries to behave as if it were an ORM.
-module Delayed
-  module Backend
-    module Mock
-      class Job
-        attr_accessor :id
-        attr_accessor :priority
-        attr_accessor :attempts
-        attr_accessor :handler
-        attr_accessor :last_error
-        attr_accessor :run_at
-        attr_accessor :locked_at
-        attr_accessor :locked_by
-        attr_accessor :failed_at
-        attr_accessor :queue
-
-        include Delayed::Backend::Base
-
-        cattr_accessor :id
-        self.id = 0
-
-        def initialize(hash = {})
-          self.attempts = 0
-          self.priority = 0
-          self.id = (self.class.id += 1)
-          hash.each{|k,v| send(:"#{k}=", v)}
-        end
-
-        @jobs = []
-        def self.all
-          @jobs
-        end
-
-        def self.count
-          all.size
-        end
-
-        def self.delete_all
-          all.clear
-        end
-
-        def self.create(attrs = {})
-          new(attrs).tap do |o|
-            o.save
-          end
-        end
-
-        def self.create!(*args); create(*args); end
-
-        def self.clear_locks!(worker_name)
-          all.select{|j| j.locked_by == worker_name}.each {|j| j.locked_by = nil; j.locked_at = nil}
-        end
-
-        # Find a few candidate jobs to run (in case some immediately get locked by others).
-        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
-          jobs = all.select do |j|
-            j.run_at <= db_time_now &&
-            (j.locked_at.nil? || j.locked_at < db_time_now - max_run_time || j.locked_by == worker_name) &&
-            j.failed_at.nil?
-          end
-
-          jobs = jobs.select{|j| Worker.queues.include?(j.queue)}   if Worker.queues.any?
-          jobs = jobs.select{|j| j.priority >= Worker.min_priority} if Worker.min_priority
-          jobs = jobs.select{|j| j.priority <= Worker.max_priority} if Worker.max_priority
-          jobs.sort_by{|j| [j.priority, j.run_at]}[0..limit-1]
-        end
-
-        # Lock this job for this worker.
-        # Returns true if we have the lock, false otherwise.
-        def lock_exclusively!(max_run_time, worker)
-          now = self.class.db_time_now
-          if locked_by != worker
-            # We don't own this job so we will update the locked_by name and the locked_at
-            self.locked_at = now
-            self.locked_by = worker
-          end
-
-          return true
-        end
-
-        def self.db_time_now
-          Time.current
-        end
-
-        def update_attributes(attrs = {})
-          attrs.each{|k,v| send(:"#{k}=", v)}
-          save
-        end
-
-        def destroy
-          self.class.all.delete(self)
-        end
-
-        def save
-          self.run_at ||= Time.current
-
-          self.class.all << self unless self.class.all.include?(self)
-          true
-        end
-
-        def save!; save; end
-
-        def reload
-          reset
-          self
-        end
-      end
-    end
-  end
-end