appsignal 2.1.0.alpha.3 → 2.1.0.beta.1

data/spec/lib/appsignal/hooks/sidekiq_spec.rb

@@ -2,18 +2,19 @@ describe Appsignal::Hooks::SidekiqPlugin do
   let(:worker) { double }
   let(:queue) { double }
   let(:current_transaction) { background_job_transaction }
-  let(:item) {{
-    'class'       => 'TestClass',
-    'retry_count' => 0,
-    'queue'       => 'default',
-    'enqueued_at' => Time.parse('01-01-2001 10:00:00UTC'),
-    'args'        => ['Model', 1],
-    'extra'       => 'data'
-  }}
+  let(:item) do
+    {
+      "class"       => "TestClass",
+      "retry_count" => 0,
+      "queue"       => "default",
+      "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC"),
+      "args"        => ["Model", 1],
+      "extra"       => "data"
+    }
+  end
   let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
 
   before do
-    Appsignal.stub(:is_ignored_exception? => false)
     Appsignal::Transaction.stub(:current => current_transaction)
     start_agent
   end
@@ -21,54 +22,56 @@ describe Appsignal::Hooks::SidekiqPlugin do
   context "with a performance call" do
     it "should wrap in a transaction with the correct params" do
       Appsignal.should_receive(:monitor_transaction).with(
-        'perform_job.sidekiq',
-        :class    => 'TestClass',
-        :method   => 'perform',
+        "perform_job.sidekiq",
+        :class    => "TestClass",
+        :method   => "perform",
         :metadata => {
-          'retry_count' => "0",
-          'queue'       => 'default',
-          'extra'       => 'data'
+          "retry_count" => "0",
+          "queue"       => "default",
+          "extra"       => "data"
         },
-        :params      => ['Model', "1"],
-        :queue_start => Time.parse('01-01-2001 10:00:00UTC'),
-        :queue_time  => 60000.to_f
+        :params      => ["Model", "1"],
+        :queue_start => Time.parse("01-01-2001 10:00:00UTC"),
+        :queue_time  => 60_000.to_f
       )
     end
 
     context "when wrapped by ActiveJob" do
-      let(:item) {{
-        "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-        "wrapped" => "TestClass",
-        "queue" => "default",
-        "args"=> [{
-          "job_class" => "TestJob",
-          "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-          "queue_name" => "default",
-          "arguments" => ['Model', 1],
-        }],
-        "retry" => true,
-        "jid" => "efb140489485999d32b5504c",
-        "created_at" => Time.parse('01-01-2001 10:00:00UTC').to_f,
-        "enqueued_at" => Time.parse('01-01-2001 10:00:00UTC').to_f
-      }}
+      let(:item) do
+        {
+          "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
+          "wrapped" => "TestClass",
+          "queue" => "default",
+          "args" => [{
+            "job_class" => "TestJob",
+            "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
+            "queue_name" => "default",
+            "arguments" => ["Model", 1]
+          }],
+          "retry" => true,
+          "jid" => "efb140489485999d32b5504c",
+          "created_at" => Time.parse("01-01-2001 10:00:00UTC").to_f,
+          "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC").to_f
+        }
+      end
 
       it "should wrap in a transaction with the correct params" do
         Appsignal.should_receive(:monitor_transaction).with(
-          'perform_job.sidekiq',
-          :class    => 'TestClass',
-          :method   => 'perform',
+          "perform_job.sidekiq",
+          :class    => "TestClass",
+          :method   => "perform",
           :metadata => {
-            'queue' => 'default'
+            "queue" => "default"
           },
-          :params      => ['Model', "1"],
-          :queue_start => Time.parse('01-01-2001 10:00:00UTC').to_f,
-          :queue_time  => 60000.to_f
+          :params      => ["Model", "1"],
+          :queue_start => Time.parse("01-01-2001 10:00:00UTC").to_f,
+          :queue_time  => 60_000.to_f
         )
       end
     end
 
     after do
-      Timecop.freeze(Time.parse('01-01-2001 10:01:00UTC')) do
+      Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
         Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
           # nothing
         end
@@ -85,7 +88,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
 
     after do
       begin
-        Timecop.freeze(Time.parse('01-01-2001 10:01:00UTC')) do
+        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
           Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
             raise error
           end
@@ -98,13 +101,13 @@ describe Appsignal::Hooks::SidekiqPlugin do
   describe "#formatted_data" do
     let(:item) do
       {
-        'foo'   => 'bar',
-        'class' => 'TestClass',
+        "foo"   => "bar",
+        "class" => "TestClass"
       }
     end
 
     it "should only add items to the hash that do not appear in JOB_KEYS" do
-      plugin.formatted_metadata(item).should eq({'foo' => 'bar'})
+      plugin.formatted_metadata(item).should eq("foo" => "bar")
     end
   end
 end

data/spec/lib/appsignal/hooks/webmachine_spec.rb

@@ -7,8 +7,8 @@ describe Appsignal::Hooks::WebmachineHook do
       its(:dependencies_present?) { should be_true }
 
       it "should include the run alias methods" do
-        expect( fsm ).to respond_to(:run_with_appsignal)
-        expect( fsm ).to respond_to(:run_without_appsignal)
+        expect(fsm).to respond_to(:run_with_appsignal)
+        expect(fsm).to respond_to(:run_without_appsignal)
       end
 
       it "should include the handle_exceptions alias methods" do

data/spec/lib/appsignal/hooks_spec.rb

@@ -27,7 +27,7 @@ class MockErrorHook < Appsignal::Hooks::Hook
   end
 
   def install
-    raise 'error'
+    raise "error"
   end
 end
 
@@ -88,20 +88,20 @@ describe Appsignal::Hooks::Helpers do
     end
 
     it "should truncate the text to 200 chars max" do
-      with_helpers.truncate(very_long_text).should eq "#{'a' * 197}..."
+      with_helpers.truncate(very_long_text).should eq "#{"a" * 197}..."
     end
   end
 
   describe "#string_or_inspect" do
     context "when string" do
       it "should return the string" do
-        with_helpers.string_or_inspect('foo').should eq 'foo'
+        with_helpers.string_or_inspect("foo").should eq "foo"
       end
     end
 
     context "when integer" do
       it "should return the string" do
-        with_helpers.string_or_inspect(1).should eq '1'
+        with_helpers.string_or_inspect(1).should eq "1"
       end
     end
 
@@ -116,12 +116,12 @@ describe Appsignal::Hooks::Helpers do
 
   describe "#extract_value" do
     context "for a hash" do
-      let(:hash) { {:key => 'value'} }
+      let(:hash) { { :key => "value" } }
 
       context "when the key exists" do
         subject { with_helpers.extract_value(hash, :key) }
 
-        it { should eq 'value' }
+        it { should eq "value" }
       end
 
       context "when the key does not exist" do
@@ -141,12 +141,12 @@ describe Appsignal::Hooks::Helpers do
       before :all do
         TestStruct = Struct.new(:key)
       end
-      let(:struct) { TestStruct.new('value') }
+      let(:struct) { TestStruct.new("value") }
 
       context "when the key exists" do
         subject { with_helpers.extract_value(struct, :key) }
 
-        it { should eq 'value' }
+        it { should eq "value" }
       end
 
       context "when the key does not exist" do
@@ -163,12 +163,12 @@ describe Appsignal::Hooks::Helpers do
     end
 
     context "for an object" do
-      let(:object) { double(:existing_method => 'value') }
+      let(:object) { double(:existing_method => "value") }
 
       context "when the method exists" do
         subject { with_helpers.extract_value(object, :existing_method) }
 
-        it { should eq 'value' }
+        it { should eq "value" }
       end
 
       context "when the method does not exist" do
@@ -182,7 +182,6 @@ describe Appsignal::Hooks::Helpers do
           it { should eq 1 }
         end
       end
-
     end
 
     context "when we need to call to_s on the value" do
@@ -190,7 +189,7 @@ describe Appsignal::Hooks::Helpers do
 
       subject { with_helpers.extract_value(object, :existing_method, nil, true) }
 
-      it { should eq '1' }
+      it { should eq "1" }
     end
   end
 
@@ -198,19 +197,19 @@ describe Appsignal::Hooks::Helpers do
     let(:object) { Object.new }
     let(:args) do
       [
-        'Model',
+        "Model",
         1,
         object,
-        'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
+        "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
       ]
     end
 
     it "should format the arguments" do
       with_helpers.format_args(args).should eq([
-        'Model',
-        '1',
+        "Model",
+        "1",
         object.inspect,
-        'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ...'
+        "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ..."
       ])
     end
   end

data/spec/lib/appsignal/integrations/data_mapper_spec.rb

@@ -1,7 +1,6 @@
-require 'appsignal/integrations/data_mapper'
+require "appsignal/integrations/data_mapper"
 
 describe Appsignal::Hooks::DataMapperLogListener do
-
   module DataMapperLog
     def log(message)
     end
@@ -29,9 +28,9 @@ describe Appsignal::Hooks::DataMapperLogListener do
     before { Appsignal::Transaction.stub(:current) { transaction } }
 
     it "should record the log entry in an event" do
-      expect( transaction ).to receive(:record_event).with(
-        'query.data_mapper',
-        'DataMapper Query',
+      expect(transaction).to receive(:record_event).with(
+        "query.data_mapper",
+        "DataMapper Query",
         "SELECT * from users",
         100,
         Appsignal::EventFormatter::SQL_BODY_FORMAT
@@ -51,9 +50,9 @@ describe Appsignal::Hooks::DataMapperLogListener do
       end
 
       it "should record the log entry in an event without body" do
-        expect( transaction ).to receive(:record_event).with(
-          'query.data_mapper',
-          'DataMapper Query',
+        expect(transaction).to receive(:record_event).with(
+          "query.data_mapper",
+          "DataMapper Query",
           "",
           100,
           Appsignal::EventFormatter::DEFAULT

data/spec/lib/appsignal/integrations/mongo_ruby_driver_spec.rb

@@ -1,24 +1,24 @@
-require 'appsignal/integrations/mongo_ruby_driver'
+require "appsignal/integrations/mongo_ruby_driver"
 describe Appsignal::Hooks::MongoMonitorSubscriber do
   let(:subscriber) { Appsignal::Hooks::MongoMonitorSubscriber.new }
 
   context "with transaction" do
     let!(:transaction) do
-      Appsignal::Transaction.create('1', 'http_request', {}, {})
+      Appsignal::Transaction.create("1", "http_request", {}, {})
     end
 
     describe "#started" do
       let(:event) do
         double(
           :request_id   => 1,
-          :command_name => 'find',
-          :command      => {'foo' => 'bar'}
+          :command_name => "find",
+          :command      => { "foo" => "bar" }
         )
       end
 
       it "should sanitize command" do
         Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter
-          .should receive(:format).with('find', {'foo' => 'bar'})
+          .should receive(:format).with("find", "foo" => "bar")
 
         subscriber.started(event)
       end
@@ -26,7 +26,7 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       it "should store command on the transaction" do
         subscriber.started(event)
 
-        transaction.store('mongo_driver').should eq({1 => {'foo' => '?'}})
+        transaction.store("mongo_driver").should eq(1 => { "foo" => "?" })
       end
 
       it "should start an event in the extension" do
@@ -40,7 +40,7 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       let(:event) { double }
 
       it "should finish the event" do
-        subscriber.should receive(:finish).with('SUCCEEDED', event)
+        subscriber.should receive(:finish).with("SUCCEEDED", event)
 
         subscriber.succeeded(event)
       end
@@ -50,42 +50,42 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       let(:event) { double }
 
       it "should finish the event" do
-        subscriber.should receive(:finish).with('FAILED', event)
+        subscriber.should receive(:finish).with("FAILED", event)
 
         subscriber.failed(event)
       end
     end
 
     describe "#finish" do
-      let(:command) { {'foo' => '?'} }
+      let(:command) { { "foo" => "?" } }
       let(:event) do
         double(
           :request_id    => 2,
           :command_name  => :find,
-          :database_name => 'test'
+          :database_name => "test"
         )
       end
 
       before do
-        store = transaction.store('mongo_driver')
+        store = transaction.store("mongo_driver")
         store[2] = command
       end
 
       it "should get the query from the store" do
-        transaction.should receive(:store).with('mongo_driver').and_return(command)
+        transaction.should receive(:store).with("mongo_driver").and_return(command)
 
-        subscriber.finish('SUCCEEDED', event)
+        subscriber.finish("SUCCEEDED", event)
       end
 
       it "should finish the transaction in the extension" do
         transaction.should receive(:finish_event).with(
-          'query.mongodb',
-          'find | test | SUCCEEDED',
-          Appsignal::Utils.data_generate({'foo' => '?'}),
+          "query.mongodb",
+          "find | test | SUCCEEDED",
+          Appsignal::Utils.data_generate("foo" => "?"),
           0
         )
 
-        subscriber.finish('SUCCEEDED', event)
+        subscriber.finish("SUCCEEDED", event)
       end
     end
   end
@@ -106,7 +106,7 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
     it "should not attempt to finish an event" do
       Appsignal::Extension.should_not receive(:finish_event)
 
-      subscriber.finish('SUCCEEDED', double)
+      subscriber.finish("SUCCEEDED", double)
     end
   end
 
@@ -123,7 +123,7 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
     it "should not attempt to finish an event" do
       Appsignal::Extension.should_not receive(:finish_event)
 
-      subscriber.finish('SUCCEEDED', double)
+      subscriber.finish("SUCCEEDED", double)
     end
   end
 end

data/spec/lib/appsignal/integrations/object_spec.rb

@@ -1,4 +1,4 @@
-require 'appsignal/integrations/object'
+require "appsignal/integrations/object"
 
 describe Object do
   describe "#instrument_method" do
@@ -84,7 +84,7 @@ describe Object do
               def foo
                 1
               end
-              appsignal_instrument_method :foo, name: "my_method.group"
+              appsignal_instrument_method :foo, :name => "my_method.group"
             end
           end
 
@@ -206,7 +206,7 @@ describe Object do
               def self.bar
                 2
               end
-              appsignal_instrument_class_method :bar, name: "my_method.group"
+              appsignal_instrument_class_method :bar, :name => "my_method.group"
             end
           end
 

data/spec/lib/appsignal/integrations/padrino_spec.rb

@@ -1,6 +1,6 @@
 if DependencyHelper.padrino_present?
-  describe "Padrino integration"   do
-    require File.expand_path('lib/appsignal/integrations/padrino.rb')
+  describe "Padrino integration" do
+    require File.expand_path("lib/appsignal/integrations/padrino.rb")
 
     class ClassWithRouter
       include Padrino::Routing
@@ -16,35 +16,35 @@ if DependencyHelper.padrino_present?
 
     describe "Appsignal::Integrations::PadrinoPlugin" do
       it "should start the logger on init" do
-        expect( Appsignal ).to receive(:start_logger)
+        expect(Appsignal).to receive(:start_logger)
       end
 
       it "should start appsignal on init" do
-        expect( Appsignal ).to receive(:start)
+        expect(Appsignal).to receive(:start)
       end
 
       context "when not active" do
         before { Appsignal.stub(:active? => false) }
 
         it "should not add the Listener middleware to the stack" do
-          expect( Padrino ).to_not receive(:use)
+          expect(Padrino).to_not receive(:use)
         end
       end
 
       context "when APPSIGNAL_APP_ENV ENV var is provided" do
-        it 'should use this as the environment' do
-          ENV['APPSIGNAL_APP_ENV'] = 'custom'
+        it "should use this as the environment" do
+          ENV["APPSIGNAL_APP_ENV"] = "custom"
 
           # Reset the plugin to pull down the latest data
           Appsignal::Integrations::PadrinoPlugin.init
 
-          expect(Appsignal.config.env).to eq 'custom'
+          expect(Appsignal.config.env).to eq "custom"
         end
       end
 
       context "when APPSIGNAL_APP_ENV ENV var is not provided" do
-        it 'should use the Padrino environment' do
-          ENV['APPSIGNAL_APP_ENV'] = nil
+        it "should use the Padrino environment" do
+          ENV["APPSIGNAL_APP_ENV"] = nil
 
           # Reset the plugin to pull down the latest data
           Appsignal::Integrations::PadrinoPlugin.init
@@ -60,17 +60,17 @@ if DependencyHelper.padrino_present?
       let(:base)     { double }
       let(:router)   { ClassWithRouter.new }
       let(:env)      { {} }
-      let(:settings) { double(:name => 'TestApp') }
+      let(:settings) { double(:name => "TestApp") }
 
       describe "#route!" do
         let(:request) do
           double(
-            :params          => {'id' => 1},
-            :session         => {'user_id' => 123},
-            :request_method  => 'GET',
-            :path            => '/users/1',
-            :controller      => 'users',
-            :action          => 'show',
+            :params          => { "id" => 1 },
+            :session         => { "user_id" => 123 },
+            :request_method  => "GET",
+            :path            => "/users/1",
+            :controller      => "users",
+            :action          => "show",
             :env             => {}
           )
         end
@@ -81,19 +81,19 @@ if DependencyHelper.padrino_present?
             :request                 => request,
             :env                     => env,
             :settings                => settings,
-            :get_payload_action      => 'controller#action'
+            :get_payload_action      => "controller#action"
           )
         end
 
         context "when Sinatra tells us it's a static file" do
-          let(:env) { {'sinatra.static_file' => true} }
+          let(:env) { { "sinatra.static_file" => true } }
 
           it "should call the original method" do
-            expect( router ).to receive(:route_without_appsignal)
+            expect(router).to receive(:route_without_appsignal)
           end
 
           it "should not instrument the request" do
-            expect( Appsignal ).to_not receive(:instrument)
+            expect(Appsignal).to_not receive(:instrument)
           end
 
           after { router.route!(base) }
@@ -103,11 +103,11 @@ if DependencyHelper.padrino_present?
           before { Appsignal.stub(:active? => false) }
 
           it "should call the original method" do
-            expect( router ).to receive(:route_without_appsignal)
+            expect(router).to receive(:route_without_appsignal)
           end
 
           it "should not instrument the request" do
-            expect( Appsignal ).to_not receive(:instrument)
+            expect(Appsignal).to_not receive(:instrument)
           end
 
           after { router.route!(base) }
@@ -115,19 +115,19 @@ if DependencyHelper.padrino_present?
 
         context "with a dynamic request" do
           let(:transaction) do
-              double(
-                :set_http_or_background_action => nil,
-                :set_http_or_background_queue_start => nil,
-                :set_metadata => nil,
-                :set_action => nil,
-                :set_error => nil
-              )
+            double(
+              :set_http_or_background_action => nil,
+              :set_http_or_background_queue_start => nil,
+              :set_metadata => nil,
+              :set_action => nil,
+              :set_error => nil
+            )
           end
           before { Appsignal::Transaction.stub(:create => transaction) }
 
           context "without an error" do
             it "should create a transaction" do
-              expect( Appsignal::Transaction ).to receive(:create).with(
+              expect(Appsignal::Transaction).to receive(:create).with(
                 kind_of(String),
                 Appsignal::Transaction::HTTP_REQUEST,
                 request
@@ -135,19 +135,19 @@ if DependencyHelper.padrino_present?
             end
 
             it "should call the original routing method" do
-              expect( router ).to receive(:route_without_appsignal)
+              expect(router).to receive(:route_without_appsignal)
             end
 
             it "should instrument the action" do
-              expect( Appsignal ).to receive(:instrument).with('process_action.padrino')
+              expect(Appsignal).to receive(:instrument).with("process_action.padrino")
             end
 
             it "should set metadata" do
-              expect( transaction ).to receive(:set_metadata).twice
+              expect(transaction).to receive(:set_metadata).twice
             end
 
             it "should set the action on the transaction" do
-              expect( transaction ).to receive(:set_action).with('controller#action')
+              expect(transaction).to receive(:set_action).with("controller#action")
             end
 
             after { router.route!(base) }
@@ -158,7 +158,7 @@ if DependencyHelper.padrino_present?
             before { router.stub(:route_without_appsignal).and_raise(error) }
 
             it "should add the exception to the current transaction" do
-              expect( transaction ).to receive(:set_error).with(error)
+              expect(transaction).to receive(:set_error).with(error)
 
               router.route!(base) rescue VerySpecificError
             end
@@ -167,37 +167,37 @@ if DependencyHelper.padrino_present?
       end
 
       describe "#get_payload_action" do
-        before { router.stub(:settings  => settings) }
+        before { router.stub(:settings => settings) }
 
         context "when request is nil" do
           it "should return the site" do
-            expect( router.get_payload_action(nil) ).to eql('TestApp')
+            expect(router.get_payload_action(nil)).to eql("TestApp")
           end
         end
 
         context "when there's no route object" do
-          let(:request) { double(:controller => 'Controller', :action => 'action') }
+          let(:request) { double(:controller => "Controller", :action => "action") }
 
           it "should return the site name, controller and action" do
-            expect( router.get_payload_action(request) ).to eql('TestApp:Controller#action')
+            expect(router.get_payload_action(request)).to eql("TestApp:Controller#action")
           end
 
           context "when there's no action" do
-            let(:request) { double(:controller => 'Controller', :fullpath => '/action') }
+            let(:request) { double(:controller => "Controller", :fullpath => "/action") }
 
             it "should return the site name, controller and fullpath" do
-              expect( router.get_payload_action(request) ).to eql('TestApp:Controller#/action')
+              expect(router.get_payload_action(request)).to eql("TestApp:Controller#/action")
             end
           end
         end
 
         context "when request has a route object" do
           let(:request)      { double }
-          let(:route_object) { double(:original_path => '/accounts/edit/:id') }
+          let(:route_object) { double(:original_path => "/accounts/edit/:id") }
           before             { request.stub(:route_obj => route_object) }
 
           it "should return the original path" do
-            expect( router.get_payload_action(request) ).to eql('TestApp:/accounts/edit/:id')
+            expect(router.get_payload_action(request)).to eql("TestApp:/accounts/edit/:id")
           end
         end
       end