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

data/spec/lib/appsignal/extension_spec.rb

@@ -1,11 +1,11 @@
-require 'fileutils'
+require "fileutils"
 
 describe "extension loading and operation" do
   describe ".agent_config" do
     subject { Appsignal::Extension.agent_config }
 
-    it { should have_key('version') }
-    it { should have_key('triples') }
+    it { should have_key("version") }
+    it { should have_key("triples") }
   end
 
   describe ".agent_version" do
@@ -37,30 +37,30 @@ describe "extension loading and operation" do
       end
 
       context "with a transaction" do
-        subject { Appsignal::Extension.start_transaction('request_id', 'http_request', 0) }
+        subject { Appsignal::Extension.start_transaction("request_id", "http_request", 0) }
 
         it "should have a start_event method" do
           subject.start_event(0)
         end
 
         it "should have a finish_event method" do
-          subject.finish_event('name', 'title', 'body', 0, 0)
+          subject.finish_event("name", "title", "body", 0, 0)
         end
 
         it "should have a record_event method" do
-          subject.record_event('name', 'title', 'body', 1000, 0, 1000)
+          subject.record_event("name", "title", "body", 1000, 0, 1000)
         end
 
         it "should have a set_error method" do
-          subject.set_error('name', 'message', Appsignal::Extension.data_map_new)
+          subject.set_error("name", "message", Appsignal::Extension.data_map_new)
         end
 
         it "should have a set_sample_data method" do
-          subject.set_sample_data('params', Appsignal::Extension.data_map_new)
+          subject.set_sample_data("params", Appsignal::Extension.data_map_new)
         end
 
         it "should have a set_action method" do
-          subject.set_action('value')
+          subject.set_action("value")
         end
 
         it "should have a set_queue_start method" do
@@ -68,7 +68,7 @@ describe "extension loading and operation" do
         end
 
         it "should have a set_metadata method" do
-          subject.set_metadata('key', 'value')
+          subject.set_metadata("key", "value")
         end
 
         it "should have a finish method" do
@@ -81,15 +81,15 @@ describe "extension loading and operation" do
       end
 
       it "should have a set_gauge method" do
-        subject.set_gauge('key', 1.0)
+        subject.set_gauge("key", 1.0)
       end
 
       it "should have a increment_counter method" do
-        subject.increment_counter('key', 1)
+        subject.increment_counter("key", 1)
       end
 
       it "should have a add_distribution_value method" do
-        subject.add_distribution_value('key', 1.0)
+        subject.add_distribution_value("key", 1.0)
       end
     end
   end
@@ -109,9 +109,9 @@ describe "extension loading and operation" do
     end
 
     it "should not raise errors when methods are called" do
-      expect {
+      expect do
         subject.something
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 end

data/spec/lib/appsignal/garbage_collection_profiler_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
-require_relative '../../support/mocks/fake_gc_profiler'
+require "spec_helper"
+require_relative "../../support/mocks/fake_gc_profiler"
 
 describe Appsignal::GarbageCollectionProfiler do
   let(:internal_profiler) { FakeGCProfiler.new }
@@ -33,8 +33,8 @@ describe Appsignal::GarbageCollectionProfiler do
   describe "when the total GC time becomes too high" do
     it "should reset" do
       profiler = Appsignal::GarbageCollectionProfiler.new
-        internal_profiler.total_time = 2_147_483_647
-        expect(profiler.total_time).to eq(0)
+      internal_profiler.total_time = 2_147_483_647
+      expect(profiler.total_time).to eq(0)
     end
   end
 
@@ -53,7 +53,8 @@ describe Appsignal::GarbageCollectionProfiler do
 
   describe "in multiple threads, with a slow GC::Profiler" do
     it "should not count garbage collection times twice" do
-      threads, results = [], []
+      threads = []
+      results = []
       internal_profiler.clear_delay = 0.001
       internal_profiler.total_time = 0.12345
 

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

@@ -4,7 +4,7 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
       start_agent
     end
     before do
-      Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
     end
 
     let(:notifier) { ActiveSupport::Notifications::Fanout.new }
@@ -13,28 +13,28 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
     its(:dependencies_present?) { should be_true }
 
     it "should instrument an AS notifications instrument call with a block" do
-      expect( Appsignal::Transaction.current ).to receive(:start_event)
+      expect(Appsignal::Transaction.current).to receive(:start_event)
         .at_least(:once)
-      expect( Appsignal::Transaction.current ).to receive(:finish_event)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
         .at_least(:once)
-        .with("sql.active_record", nil, 'SQL', 1)
+        .with("sql.active_record", nil, "SQL", 1)
 
-      return_value = instrumenter.instrument('sql.active_record', :sql => 'SQL') do
-        'value'
+      return_value = instrumenter.instrument("sql.active_record", :sql => "SQL") do
+        "value"
       end
 
-      expect(return_value).to eq 'value'
+      expect(return_value).to eq "value"
     end
 
     it "should not instrument events whose name starts with a bang" do
-      expect( Appsignal::Transaction.current ).not_to receive(:start_event)
-      expect( Appsignal::Transaction.current ).not_to receive(:finish_event)
+      expect(Appsignal::Transaction.current).not_to receive(:start_event)
+      expect(Appsignal::Transaction.current).not_to receive(:finish_event)
 
-      return_value = instrumenter.instrument('!sql.active_record', :sql => 'SQL') do
-        'value'
+      return_value = instrumenter.instrument("!sql.active_record", :sql => "SQL") do
+        "value"
       end
 
-      expect(return_value).to eq 'value'
+      expect(return_value).to eq "value"
     end
   else
     its(:dependencies_present?) { should be_false }

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

@@ -25,36 +25,36 @@ describe Appsignal::Hooks::DelayedJobHook do
 
     describe ".invoke_with_instrumentation" do
       let(:plugin) { Appsignal::Hooks::DelayedJobPlugin }
-      let(:time) { Time.parse('01-01-2001 10:01:00UTC') }
+      let(:time) { Time.parse("01-01-2001 10:01:00UTC") }
       let(:job_data) do
         {
           :id             => 123,
-          :name           => 'TestClass#perform',
+          :name           => "TestClass#perform",
           :priority       => 1,
           :attempts       => 1,
-          :queue          => 'default',
+          :queue          => "default",
           :created_at     => time - 60_000,
-          :payload_object => double(:args => ['argument']),
+          :payload_object => double(:args => ["argument"])
         }
       end
       let(:job) { double(job_data) }
-      let(:invoked_block) { Proc.new { } }
+      let(:invoked_block) { proc {} }
       let(:error) { StandardError.new }
 
       context "with a normal call" do
         it "should wrap in a transaction with the correct params" do
           Appsignal.should_receive(:monitor_transaction).with(
-            'perform_job.delayed_job',
-            :class    => 'TestClass',
-            :method   => 'perform',
+            "perform_job.delayed_job",
+            :class    => "TestClass",
+            :method   => "perform",
             :metadata => {
               :priority => 1,
               :attempts => 1,
-              :queue    => 'default',
-              :id       => '123'
+              :queue    => "default",
+              :id       => "123"
             },
-            :params      => ['argument'],
-            :queue_start => time - 60_000,
+            :params      => ["argument"],
+            :queue_start => time - 60_000
           )
 
           Timecop.freeze(time) do
@@ -66,29 +66,29 @@ describe Appsignal::Hooks::DelayedJobHook do
           let(:job_data) do
             {
               :payload_object => double(
-                :appsignal_name => 'CustomClass#perform',
-                :args           => ['argument']
+                :appsignal_name => "CustomClass#perform",
+                :args           => ["argument"]
               ),
-              :id         => '123',
-              :name       => 'TestClass#perform',
+              :id         => "123",
+              :name       => "TestClass#perform",
               :priority   => 1,
               :attempts   => 1,
-              :queue      => 'default',
+              :queue      => "default",
               :created_at => time - 60_000
             }
           end
           it "should wrap in a transaction with the correct params" do
             Appsignal.should_receive(:monitor_transaction).with(
-              'perform_job.delayed_job',
-              :class => 'CustomClass',
-              :method => 'perform',
+              "perform_job.delayed_job",
+              :class => "CustomClass",
+              :method => "perform",
               :metadata => {
                 :priority => 1,
                 :attempts => 1,
-                :queue    => 'default',
-                :id       => '123'
+                :queue    => "default",
+                :id       => "123"
               },
-              :params      => ['argument'],
+              :params      => ["argument"],
               :queue_start => time - 60_000
             )
 
@@ -99,27 +99,27 @@ describe Appsignal::Hooks::DelayedJobHook do
         end
 
         if active_job_present?
-          require 'active_job'
+          require "active_job"
 
           context "when wrapped by ActiveJob" do
             before do
-              job_data[:args] = ['argument']
+              job_data[:args] = ["argument"]
             end
             let(:job) { ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(job_data) }
 
             it "should wrap in a transaction with the correct params" do
               Appsignal.should_receive(:monitor_transaction).with(
-                'perform_job.delayed_job',
-                :class    => 'TestClass',
-                :method   => 'perform',
+                "perform_job.delayed_job",
+                :class    => "TestClass",
+                :method   => "perform",
                 :metadata => {
                   :priority => 1,
                   :attempts => 1,
-                  :queue    => 'default',
-                  :id       => '123'
+                  :queue    => "default",
+                  :id       => "123"
                 },
-                :params      => ['argument'],
-                :queue_start => time - 60_000,
+                :params      => ["argument"],
+                :queue_start => time - 60_000
               )
 
               Timecop.freeze(time) do
@@ -137,9 +137,9 @@ describe Appsignal::Hooks::DelayedJobHook do
 
           invoked_block.stub(:call).and_raise(error)
 
-          lambda {
+          lambda do
             plugin.invoke_with_instrumentation(job, invoked_block)
-          }.should raise_error(StandardError)
+          end.should raise_error(StandardError)
         end
       end
     end

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

@@ -1,5 +1,5 @@
 describe Appsignal::Hooks::MongoRubyDriverHook do
-  require 'appsignal/integrations/mongo_ruby_driver'
+  require "appsignal/integrations/mongo_ruby_driver"
 
   context "with mongo ruby driver" do
     let(:subscriber) { Appsignal::Hooks::MongoMonitorSubscriber.new }
@@ -8,7 +8,7 @@ describe Appsignal::Hooks::MongoRubyDriverHook do
     before(:all) do
       module Mongo
         module Monitoring
-          COMMAND = 'command'
+          COMMAND = "command"
 
           class Global
             def subscribe
@@ -23,7 +23,7 @@ describe Appsignal::Hooks::MongoRubyDriverHook do
 
     it "adds a subscriber to Mongo::Monitoring" do
       Mongo::Monitoring::Global.should receive(:subscribe)
-        .with('command', subscriber)
+        .with("command", subscriber)
         .at_least(:once)
 
       Appsignal::Hooks::MongoRubyDriverHook.new.install

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

@@ -7,29 +7,29 @@ describe Appsignal::Hooks::NetHttpHook do
     its(:dependencies_present?) { should be_true }
 
     it "should instrument a http request" do
-      Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
-      expect( Appsignal::Transaction.current ).to receive(:start_event)
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+      expect(Appsignal::Transaction.current).to receive(:start_event)
         .at_least(:once)
-      expect( Appsignal::Transaction.current ).to receive(:finish_event)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
         .at_least(:once)
         .with("request.net_http", "GET http://www.google.com", nil, 0)
 
-      stub_request(:any, 'http://www.google.com/')
+      stub_request(:any, "http://www.google.com/")
 
-      Net::HTTP.get_response(URI.parse('http://www.google.com'))
+      Net::HTTP.get_response(URI.parse("http://www.google.com"))
     end
 
     it "should instrument a https request" do
-      Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
-      expect( Appsignal::Transaction.current ).to receive(:start_event)
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+      expect(Appsignal::Transaction.current).to receive(:start_event)
         .at_least(:once)
-      expect( Appsignal::Transaction.current ).to receive(:finish_event)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
         .at_least(:once)
         .with("request.net_http", "GET https://www.google.com", nil, 0)
 
-      stub_request(:any, 'https://www.google.com/')
+      stub_request(:any, "https://www.google.com/")
 
-      uri = URI.parse('https://www.google.com')
+      uri = URI.parse("https://www.google.com")
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
       http.get(uri.request_uri)

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

@@ -1,7 +1,7 @@
-require 'rake'
+require "rake"
 
 describe Appsignal::Hooks::RakeHook do
-  let(:task) { Rake::Task.new('task:name', Rake::Application.new) }
+  let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
   before(:all) do
     Appsignal.config = project_fixture_config
     expect(Appsignal.active?).to be_true
@@ -15,10 +15,10 @@ describe Appsignal::Hooks::RakeHook do
       end
 
       it "calls the original task" do
-        expect(task).to receive(:execute_without_appsignal).with('foo')
+        expect(task).to receive(:execute_without_appsignal).with("foo")
       end
 
-      after { task.execute('foo') }
+      after { task.execute("foo") }
     end
 
     context "with error" do
@@ -35,7 +35,7 @@ describe Appsignal::Hooks::RakeHook do
       end
 
       it "sets the action" do
-        expect(transaction).to receive(:set_action).with('task:name')
+        expect(transaction).to receive(:set_action).with("task:name")
       end
 
       it "sets the error" do
@@ -44,11 +44,11 @@ describe Appsignal::Hooks::RakeHook do
 
       it "completes the transaction and stops" do
         expect(transaction).to receive(:complete).ordered
-        expect(Appsignal).to receive(:stop).with('rake').ordered
+        expect(Appsignal).to receive(:stop).with("rake").ordered
       end
 
       after do
-        expect { task.execute('foo') }.to raise_error VerySpecificError
+        expect { task.execute("foo") }.to raise_error VerySpecificError
       end
     end
   end

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

@@ -8,11 +8,11 @@ describe Appsignal::Hooks::RedisHook do
       before :all do
         class Redis
           class Client
-            def process(commands, &block)
+            def process(_commands)
               1
             end
           end
-          VERSION = '1.0'
+          VERSION = "1.0"
         end
       end
 
@@ -26,12 +26,12 @@ describe Appsignal::Hooks::RedisHook do
         its(:dependencies_present?) { should be_true }
 
         it "should instrument a redis call" do
-          Appsignal::Transaction.create('uuid', Appsignal::Transaction::HTTP_REQUEST, 'test')
-          expect( Appsignal::Transaction.current ).to receive(:start_event)
+          Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+          expect(Appsignal::Transaction.current).to receive(:start_event)
             .at_least(:once)
-          expect( Appsignal::Transaction.current ).to receive(:finish_event)
+          expect(Appsignal::Transaction.current).to receive(:finish_event)
             .at_least(:once)
-            .with('query.redis', nil, nil, 0)
+            .with("query.redis", nil, nil, 0)
 
           client = Redis::Client.new
 

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

@@ -3,43 +3,42 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
 
   let(:worker_instance) { double }
   let(:queue) { double }
-  let(:sqs_msg) {
-    double(:attributes => {})
-  }
-  let(:body) {{}}
+  let(:sqs_msg) { double(:attributes => {}) }
+  let(:body) { {} }
 
   before do
-    Appsignal.stub(:is_ignored_exception? => false)
     Appsignal::Transaction.stub(:current => current_transaction)
     start_agent
   end
 
   context "with a performance call" do
-    let(:queue) { 'some-funky-queue-name' }
-    let(:sqs_msg) {
-      double(:attributes => { 'SentTimestamp' => Time.parse('1976-11-18 0:00:00UTC').to_i * 1000 })
-    }
-    let(:body) {{
-      'job_class' => 'TestClass',
-      'arguments' => ['Model', "1"],
-    }}
+    let(:queue) { "some-funky-queue-name" }
+    let(:sqs_msg) do
+      double(:attributes => { "SentTimestamp" => Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 })
+    end
+    let(:body) do
+      {
+        "job_class" => "TestClass",
+        "arguments" => ["Model", "1"]
+      }
+    end
 
     it "should wrap in a transaction with the correct params" do
       Appsignal.should_receive(:monitor_transaction).with(
-        'perform_job.shoryuken',
-        :class => 'TestClass',
-        :method => 'perform',
+        "perform_job.shoryuken",
+        :class => "TestClass",
+        :method => "perform",
         :metadata => {
-          :queue => 'some-funky-queue-name',
-          'SentTimestamp' => 217123200000
+          :queue => "some-funky-queue-name",
+          "SentTimestamp" => 217_123_200_000
         },
-        :params => ['Model', "1"],
-        :queue_start => Time.parse('1976-11-18 0:00:00UTC').utc
+        :params => ["Model", "1"],
+        :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
       )
     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::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
           # nothing
         end
@@ -56,7 +55,7 @@ describe Appsignal::Hooks::ShoryukenMiddleware 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::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
             raise error
           end