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

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

@@ -2,7 +2,7 @@ if DependencyHelper.rails_present?
   describe Appsignal::Integrations::Railtie do
     context "after initializing the app" do
       it "should call initialize_appsignal" do
-        expect( Appsignal::Integrations::Railtie ).to receive(:initialize_appsignal)
+        expect(Appsignal::Integrations::Railtie).to receive(:initialize_appsignal)
 
         MyApp::Application.config.root = project_fixture_path
         MyApp::Application.initialize!
@@ -23,36 +23,36 @@ if DependencyHelper.rails_present?
       context "config" do
         subject { Appsignal.config }
         context "basics" do
-          before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+          before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
 
           it { should be_a(Appsignal::Config) }
 
           its(:root_path)  { should eq Pathname.new(project_fixture_path) }
-          its(:env)        { should eq 'test' }
-          its([:name])     { should eq 'TestApp' }
-          its([:log_path]) { should eq Pathname.new(File.join(project_fixture_path, 'log')) }
+          its(:env)        { should eq "test" }
+          its([:name])     { should eq "TestApp" }
+          its([:log_path]) { should eq Pathname.new(File.join(project_fixture_path, "log")) }
         end
 
         context "initial config" do
           before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
           subject { Appsignal.config.initial_config }
 
-          its([:name]) { should eq 'MyApp' }
+          its([:name]) { should eq "MyApp" }
         end
 
         context "with APPSIGNAL_APP_ENV ENV var set" do
           before do
-            ENV.should_receive(:fetch).with('APPSIGNAL_APP_ENV', 'test').and_return('env_test')
+            ENV.should_receive(:fetch).with("APPSIGNAL_APP_ENV", "test").and_return("env_test")
             Appsignal::Integrations::Railtie.initialize_appsignal(app)
           end
 
-          its(:env) { should eq 'env_test' }
+          its(:env) { should eq "env_test" }
         end
       end
 
       context "listener middleware" do
         it "should have added the listener middleware" do
-          expect( app.middleware ).to receive(:insert_before).with(
+          expect(app.middleware).to receive(:insert_before).with(
             ActionDispatch::RemoteIp,
             Appsignal::Rack::RailsInstrumentation
           )
@@ -62,8 +62,8 @@ if DependencyHelper.rails_present?
           let(:config) do
             Appsignal::Config.new(
               project_fixture_path,
-              'test',
-              :name => 'MyApp',
+              "test",
+              :name => "MyApp",
               :enable_frontend_error_catching => true
             )
           end
@@ -73,12 +73,12 @@ if DependencyHelper.rails_present?
           end
 
           it "should have added the listener and JSExceptionCatcher middleware" do
-            expect( app.middleware ).to receive(:insert_before).with(
+            expect(app.middleware).to receive(:insert_before).with(
               ActionDispatch::RemoteIp,
               Appsignal::Rack::RailsInstrumentation
             )
 
-            expect( app.middleware ).to receive(:insert_before).with(
+            expect(app.middleware).to receive(:insert_before).with(
               Appsignal::Rack::RailsInstrumentation,
               Appsignal::Rack::JSExceptionCatcher
             )

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

@@ -1,6 +1,6 @@
 if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
   describe "Resque ActiveJob integration" do
-    let(:file) { File.expand_path('lib/appsignal/integrations/resque_active_job.rb') }
+    let(:file) { File.expand_path("lib/appsignal/integrations/resque_active_job.rb") }
 
     context "with Resque and ActiveJob" do
       before do
@@ -17,17 +17,17 @@ if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
 
       describe :around_perform_plugin do
         before    { SecureRandom.stub(:uuid => 123) }
-        let(:job) { TestActiveJob.new('moo') }
+        let(:job) { TestActiveJob.new("moo") }
 
         it "should wrap in a transaction with the correct params" do
           Appsignal.should_receive(:monitor_single_transaction).with(
-            'perform_job.resque',
-            :class  => 'TestActiveJob',
-            :method => 'perform',
-            :params => ['moo'],
+            "perform_job.resque",
+            :class  => "TestActiveJob",
+            :method => "perform",
+            :params => ["moo"],
             :metadata => {
               :id    => 123,
-              :queue => 'default'
+              :queue => "default"
             }
           )
         end

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

@@ -1,6 +1,6 @@
 if DependencyHelper.resque_present?
   describe "Resque integration" do
-    let(:file) { File.expand_path('lib/appsignal/integrations/resque.rb') }
+    let(:file) { File.expand_path("lib/appsignal/integrations/resque.rb") }
 
     context "with resque" do
       before do
@@ -24,8 +24,8 @@ if DependencyHelper.resque_present?
       end
 
       describe :around_perform_resque_plugin do
-        let(:transaction) { Appsignal::Transaction.new('1', 'background', {}, {}) }
-        let(:job) { ::Resque::Job.new('default', {'class' => 'TestJob'}) }
+        let(:transaction) { Appsignal::Transaction.new("1", "background", {}, {}) }
+        let(:job) { ::Resque::Job.new("default", "class" => "TestJob") }
         before do
           transaction.stub(:complete => true)
           Appsignal::Transaction.stub(:current => transaction)
@@ -39,9 +39,9 @@ if DependencyHelper.resque_present?
 
           it "should wrap in a transaction with the correct params" do
             Appsignal.should_receive(:monitor_transaction).with(
-              'perform_job.resque',
-              :class => 'TestJob',
-              :method => 'perform'
+              "perform_job.resque",
+              :class => "TestJob",
+              :method => "perform"
             )
           end
 
@@ -49,11 +49,11 @@ if DependencyHelper.resque_present?
             transaction.should_receive(:complete)
           end
 
-          after { job.perform  }
+          after { job.perform }
         end
 
         context "with exception" do
-          let(:job) { ::Resque::Job.new('default', {'class' => 'BrokenTestJob'}) }
+          let(:job) { ::Resque::Job.new("default", "class" => "BrokenTestJob") }
 
           it "should set the exception" do
             Appsignal::Transaction.any_instance.should_receive(:set_error)

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

@@ -1,6 +1,6 @@
 if DependencyHelper.sinatra_present?
-  ENV['APPSIGNAL_PUSH_API_KEY'] = 'key'
-  require 'appsignal/integrations/sinatra'
+  ENV["APPSIGNAL_PUSH_API_KEY"] = "key"
+  require "appsignal/integrations/sinatra"
 
   describe "Sinatra integration" do
     context "Appsignal.logger" do
@@ -22,22 +22,22 @@ if DependencyHelper.sinatra_present?
 
       context "without APPSIGNAL_APP_ENV" do
         before do
-          load File.expand_path('lib/appsignal/integrations/sinatra.rb', project_dir)
+          load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
         end
 
         it "uses the app environment" do
-          expect(subject).to eq('test')
+          expect(subject).to eq("test")
         end
       end
 
       context "with APPSIGNAL_APP_ENV" do
         before do
-          ENV['APPSIGNAL_APP_ENV'] = 'env-staging'
-          load File.expand_path('lib/appsignal/integrations/sinatra.rb', project_dir)
+          ENV["APPSIGNAL_APP_ENV"] = "env-staging"
+          load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
         end
 
         it "uses the environment variable" do
-          expect(subject).to eq('env-staging')
+          expect(subject).to eq("env-staging")
         end
       end
     end

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

@@ -1,9 +1,9 @@
 if DependencyHelper.webmachine_present?
-  require 'appsignal/integrations/webmachine'
+  require "appsignal/integrations/webmachine"
 
   describe Appsignal::Integrations::WebmachinePlugin::FSM do
     let(:request) do
-      Webmachine::Request.new('GET', 'http://google.com:80/foo', {}, nil)
+      Webmachine::Request.new("GET", "http://google.com:80/foo", {}, nil)
     end
     let(:resource)    { double(:trace? => false, :handle_exception => true) }
     let(:response)    { double }
@@ -14,41 +14,41 @@ if DependencyHelper.webmachine_present?
     # Make sure the request responds to the method we need to get query params.
     describe "request" do
       it "should respond to `query`" do
-        expect( request ).to respond_to(:query)
+        expect(request).to respond_to(:query)
       end
     end
 
     describe "#run_with_appsignal" do
       before do
-        allow( fsm                    ).to receive(:request).and_return(request)
-        allow( fsm                    ).to receive(:run_without_appsignal).and_return(true)
-        allow( SecureRandom           ).to receive(:uuid).and_return( 'uuid')
-        allow( Appsignal::Transaction ).to receive(:create).and_return(transaction)
+        allow(fsm).to receive(:request).and_return(request)
+        allow(fsm).to receive(:run_without_appsignal).and_return(true)
+        allow(SecureRandom).to receive(:uuid).and_return("uuid")
+        allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
       end
 
       it "should create a transaction" do
-        expect( Appsignal::Transaction ).to receive(:create).with(
-          'uuid',
+        expect(Appsignal::Transaction).to receive(:create).with(
+          "uuid",
           Appsignal::Transaction::HTTP_REQUEST,
           request,
-          {:params_method => :query}
+          :params_method => :query
         ).and_return(transaction)
       end
 
       it "should set the action" do
-        expect( transaction ).to receive(:set_action).with("RSpec::Mocks::Mock#GET")
+        expect(transaction).to receive(:set_action).with("RSpec::Mocks::Mock#GET")
       end
 
       it "should call the original method" do
-        expect( fsm ).to receive(:run_without_appsignal)
+        expect(fsm).to receive(:run_without_appsignal)
       end
 
       it "should instrument the original method" do
-        expect( Appsignal ).to receive(:instrument).with('process_action.webmachine')
+        expect(Appsignal).to receive(:instrument).with("process_action.webmachine")
       end
 
       it "should close the transaction" do
-        expect( Appsignal::Transaction ).to receive(:complete_current!)
+        expect(Appsignal::Transaction).to receive(:complete_current!)
       end
 
       after { fsm.run }
@@ -58,7 +58,7 @@ if DependencyHelper.webmachine_present?
       let(:error) { VerySpecificError.new }
 
       it "should catch the error and send it to AppSignal" do
-        expect( Appsignal ).to receive(:set_error).with(error)
+        expect(Appsignal).to receive(:set_error).with(error)
       end
 
       after do

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -1,27 +1,27 @@
 describe Appsignal::JSExceptionTransaction do
-  before { SecureRandom.stub(:uuid => '123abc') }
+  before { SecureRandom.stub(:uuid => "123abc") }
 
   let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
   let(:data) do
     {
-      'name'        => 'TypeError',
-      'message'     => 'foo is not a valid method',
-      'action'      => 'ExceptionIncidentComponent',
-      'path'        => 'foo.bar/moo',
-      'environment' => 'development',
-      'backtrace'   => [
-        'foo.bar/js:11:1',
-        'foo.bar/js:22:2',
+      "name"        => "TypeError",
+      "message"     => "foo is not a valid method",
+      "action"      => "ExceptionIncidentComponent",
+      "path"        => "foo.bar/moo",
+      "environment" => "development",
+      "backtrace"   => [
+        "foo.bar/js:11:1",
+        "foo.bar/js:22:2"
       ],
-      'tags'        => [
-        'tag1'
+      "tags" => [
+        "tag1"
       ]
     }
   end
 
   describe "#initialize" do
     it "should call all required methods" do
-      expect(Appsignal::Extension).to receive(:start_transaction).with('123abc', 'frontend', 0).and_return(1)
+      expect(Appsignal::Extension).to receive(:start_transaction).with("123abc", "frontend", 0).and_return(1)
 
       expect(transaction).to receive(:set_action)
       expect(transaction).to receive(:set_metadata)
@@ -37,7 +37,7 @@ describe Appsignal::JSExceptionTransaction do
   describe "#set_action" do
     it "should call `Appsignal::Extension.set_action`" do
       expect(transaction.ext).to receive(:set_action).with(
-        'ExceptionIncidentComponent'
+        "ExceptionIncidentComponent"
       )
 
       transaction.set_action
@@ -47,8 +47,8 @@ describe Appsignal::JSExceptionTransaction do
   describe "#set_metadata" do
     it "should call `Appsignal::Extension.set_transaction_metadata`" do
       expect(transaction.ext).to receive(:set_metadata).with(
-        'path',
-        'foo.bar/moo'
+        "path",
+        "foo.bar/moo"
       )
 
       transaction.set_metadata
@@ -58,9 +58,9 @@ describe Appsignal::JSExceptionTransaction do
   describe "#set_error" do
     it "should call `Appsignal::Extension.set_transaction_error`" do
       expect(transaction.ext).to receive(:set_error).with(
-        'TypeError',
-        'foo is not a valid method',
-        Appsignal::Utils.data_generate(['foo.bar/js:11:1', 'foo.bar/js:22:2'])
+        "TypeError",
+        "foo is not a valid method",
+        Appsignal::Utils.data_generate(["foo.bar/js:11:1", "foo.bar/js:22:2"])
       )
 
       transaction.set_error
@@ -70,8 +70,8 @@ describe Appsignal::JSExceptionTransaction do
   describe "#set_sample_data" do
     it "should call `Appsignal::Extension.set_transaction_error_data`" do
       expect(transaction.ext).to receive(:set_sample_data).with(
-        'tags',
-        Appsignal::Utils.data_generate(['tag1'])
+        "tags",
+        Appsignal::Utils.data_generate(["tag1"])
       )
 
       transaction.set_sample_data
@@ -79,7 +79,7 @@ describe Appsignal::JSExceptionTransaction do
   end
 
   context "when sending just the name" do
-    let(:data) { {'name' => 'TypeError'} }
+    let(:data) { { "name" => "TypeError" } }
 
     describe "#set_action" do
       it "should not call `Appsignal::Extension.set_action`" do
@@ -100,8 +100,8 @@ describe Appsignal::JSExceptionTransaction do
     describe "#set_error" do
       it "should call `Appsignal::Extension.set_transaction_error` with just the name" do
         expect(transaction.ext).to receive(:set_error).with(
-          'TypeError',
-          '',
+          "TypeError",
+          "",
           Appsignal::Utils.data_generate([])
         )
 

data/spec/lib/appsignal/marker_spec.rb

@@ -3,10 +3,10 @@ describe Appsignal::Marker do
   let(:marker) do
     described_class.new(
       {
-        :revision => '503ce0923ed177a3ce000005',
-        :repository => 'master',
-        :user => 'batman',
-        :rails_env => 'production'
+        :revision => "503ce0923ed177a3ce000005",
+        :repository => "master",
+        :user => "batman",
+        :rails_env => "production"
       },
       config
     )
@@ -29,8 +29,8 @@ describe Appsignal::Marker do
       it "outputs success" do
         run
         expect(output).to include \
-          'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
-          'AppSignal has been notified of this deploy!'
+          "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
+          "AppSignal has been notified of this deploy!"
       end
     end
 
@@ -40,11 +40,11 @@ describe Appsignal::Marker do
       it "outputs failure" do
         run
         expect(output).to include \
-          'Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman',
+          "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
           "Something went wrong while trying to notify AppSignal: 500 at "\
           "#{config[:endpoint]}/1/markers"
         expect(output).to_not include \
-          'AppSignal has been notified of this deploy!'
+          "AppSignal has been notified of this deploy!"
       end
     end
   end

data/spec/lib/appsignal/minutely_spec.rb

@@ -4,13 +4,13 @@ describe Appsignal::Minutely do
   end
 
   it "should have a list of probes" do
-    expect( Appsignal::Minutely.probes ).to be_instance_of(Array)
+    expect(Appsignal::Minutely.probes).to be_instance_of(Array)
   end
 
   describe ".start" do
     it "should call the probes periodically" do
       probe = double
-      expect( probe ).to receive(:call).at_least(:twice)
+      expect(probe).to receive(:call).at_least(:twice)
       Appsignal::Minutely.probes << probe
       Appsignal::Minutely.stub(:wait_time => 0.1)
 
@@ -23,18 +23,18 @@ describe Appsignal::Minutely do
   describe ".wait_time" do
     it "should get the time to the next minute" do
       Time.any_instance.stub(:sec => 30)
-      expect( Appsignal::Minutely.wait_time ).to eq 30
+      expect(Appsignal::Minutely.wait_time).to eq 30
     end
   end
 
   describe ".add_gc_probe" do
     it "should add the gc probe to the list" do
-      expect( Appsignal::Minutely.probes ).to be_empty
+      expect(Appsignal::Minutely.probes).to be_empty
 
       Appsignal::Minutely.add_gc_probe
 
-      expect( Appsignal::Minutely.probes ).to have(1).item
-      expect( Appsignal::Minutely.probes[0] ).to be_instance_of(Appsignal::Minutely::GCProbe)
+      expect(Appsignal::Minutely.probes).to have(1).item
+      expect(Appsignal::Minutely.probes[0]).to be_instance_of(Appsignal::Minutely::GCProbe)
     end
   end
 

data/spec/lib/appsignal/rack/generic_instrumentation_spec.rb

@@ -4,7 +4,7 @@ describe Appsignal::Rack::GenericInstrumentation do
   end
 
   let(:app) { double(:call => true) }
-  let(:env) { {:path => '/', :method => 'GET'} }
+  let(:env) { { :path => "/", :method => "GET" } }
   let(:options) { {} }
   let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, options) }
 
@@ -17,7 +17,7 @@ describe Appsignal::Rack::GenericInstrumentation do
       before { Appsignal.stub(:active? => true) }
 
       it "should call with monitoring" do
-        expect( middleware ).to receive(:call_with_appsignal_monitoring).with(env)
+        expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
       end
     end
 
@@ -25,11 +25,11 @@ describe Appsignal::Rack::GenericInstrumentation do
       before { Appsignal.stub(:active? => false) }
 
       it "should not call with monitoring" do
-        expect( middleware ).to_not receive(:call_with_appsignal_monitoring)
+        expect(middleware).to_not receive(:call_with_appsignal_monitoring)
       end
 
       it "should call the stack" do
-        expect( app ).to receive(:call).with(env)
+        expect(app).to receive(:call).with(env)
       end
     end
 
@@ -63,16 +63,16 @@ describe Appsignal::Rack::GenericInstrumentation do
     end
 
     it "should set the action to unknown" do
-      Appsignal::Transaction.any_instance.should_receive(:set_action).with('unknown')
+      Appsignal::Transaction.any_instance.should_receive(:set_action).with("unknown")
     end
 
     context "with a route specified in the env" do
       before do
-        env['appsignal.route'] = 'GET /'
+        env["appsignal.route"] = "GET /"
       end
 
       it "should set the action" do
-        Appsignal::Transaction.any_instance.should_receive(:set_action).with('GET /')
+        Appsignal::Transaction.any_instance.should_receive(:set_action).with("GET /")
       end
     end