appsignal 2.1.2 → 2.2.0.beta.1

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

@@ -8,7 +8,7 @@ describe Appsignal::Hooks::MongoRubyDriverHook do
     before(:context) do
       module Mongo
         module Monitoring
-          COMMAND = "command"
+          COMMAND = "command".freeze
 
           class Global
             def subscribe

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

@@ -1,52 +1,50 @@
 describe Appsignal::Hooks::RedisHook do
-  before :context do
-    start_agent
+  before do
+    Appsignal.config = project_fixture_config
+    Appsignal::Hooks.load_hooks
   end
 
-  context "with redis" do
-    before :context do
-      class Redis
-        class Client
-          def process(_commands)
-            1
-          end
+  if DependencyHelper.redis_present?
+    context "with redis" do
+      context "with instrumentation enabled" do
+        before do
+          Appsignal.config.config_hash[:instrument_redis] = true
+          allow_any_instance_of(Redis::Client).to receive(:process_without_appsignal).and_return(1)
         end
-        VERSION = "1.0"
-      end
-    end
 
-    context "with instrumentation enabled" do
-      before :context do
-        Appsignal.config.config_hash[:instrument_redis] = true
-        Appsignal::Hooks::RedisHook.new.install
-      end
-      after(:context) { Object.send(:remove_const, :Redis) }
+        describe "#dependencies_present?" do
+          subject { described_class.new.dependencies_present? }
 
-      describe "#dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
+          it { is_expected.to be_truthy }
+        end
+
+        it "should instrument a redis call" do
+          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)
+            .at_least(:once)
+            .with("query.redis", nil, nil, 0)
 
-        it { is_expected.to be_truthy }
+          client = Redis::Client.new
+          expect(client.process([])).to eq 1
+        end
       end
 
-      it "should instrument a redis call" do
-        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)
-          .at_least(:once)
-          .with("query.redis", nil, nil, 0)
+      context "with instrumentation disabled" do
+        before do
+          Appsignal.config.config_hash[:instrument_redis] = false
+        end
 
-        client = Redis::Client.new
+        describe "#dependencies_present?" do
+          subject { described_class.new.dependencies_present? }
 
-        expect(client.process([])).to eq 1
+          it { is_expected.to be_falsy }
+        end
       end
     end
-
-    context "with instrumentation disabled" do
-      before :context do
-        Appsignal.config.config_hash[:instrument_net_http] = false
-      end
-
+  else
+    context "without redis" do
       describe "#dependencies_present?" do
         subject { described_class.new.dependencies_present? }
 
@@ -54,12 +52,4 @@ describe Appsignal::Hooks::RedisHook do
       end
     end
   end
-
-  context "without redis" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
 end

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

@@ -30,7 +30,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
           "queue"       => "default",
           "extra"       => "data"
         },
-        :params      => ["Model", "1"],
+        :params      => %w(Model 1),
         :queue_start => Time.parse("01-01-2001 10:00:00UTC"),
         :queue_time  => 60_000.to_f
       )
@@ -63,7 +63,7 @@ describe Appsignal::Hooks::SidekiqPlugin do
           :metadata => {
             "queue" => "default"
           },
-          :params      => ["Model", "1"],
+          :params      => %w(Model 1),
           :queue_start => Time.parse("01-01-2001 10:00:00UTC").to_f,
           :queue_time  => 60_000.to_f
         )

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

@@ -64,7 +64,7 @@ if DependencyHelper.grape_present?
 
           it "sets metadata" do
             expect(transaction).to receive(:set_http_or_background_queue_start)
-            expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/ping")
+            expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/ping")
             expect(transaction).to receive(:set_metadata).with("path", "/ping")
             expect(transaction).to receive(:set_metadata).with("method", "POST")
           end
@@ -84,7 +84,7 @@ if DependencyHelper.grape_present?
 
           it "sets metadata" do
             expect(transaction).to receive(:set_http_or_background_queue_start)
-            expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/ping")
+            expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/ping")
             expect(transaction).to receive(:set_metadata).with("path", "/ping")
             expect(transaction).to receive(:set_metadata).with("method", "POST")
           end
@@ -143,7 +143,7 @@ if DependencyHelper.grape_present?
           end
 
           it "sets non-unique route_param path" do
-            expect(transaction).to receive(:set_action).with("GET::GrapeExample::Api#/users/:id/")
+            expect(transaction).to receive(:set_action_if_nil).with("GET::GrapeExample::Api#/users/:id/")
             expect(transaction).to receive(:set_metadata).with("path", "/users/:id/")
             expect(transaction).to receive(:set_metadata).with("method", "GET")
           end
@@ -167,7 +167,7 @@ if DependencyHelper.grape_present?
             end
 
             it "sets namespaced path" do
-              expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/v1/beta/ping")
+              expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
               expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
               expect(transaction).to receive(:set_metadata).with("method", "POST")
             end
@@ -189,7 +189,7 @@ if DependencyHelper.grape_present?
               end
 
               it "sets namespaced path" do
-                expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("method", "POST")
               end
@@ -210,7 +210,7 @@ if DependencyHelper.grape_present?
               end
 
               it "sets namespaced path" do
-                expect(transaction).to receive(:set_action).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("method", "POST")
               end

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

@@ -1,10 +1,6 @@
 if DependencyHelper.padrino_present?
   describe "Padrino integration" do
-    require File.expand_path("lib/appsignal/integrations/padrino.rb")
-
-    class ClassWithRouter
-      include Padrino::Routing
-    end
+    require "appsignal/integrations/padrino"
 
     before do
       allow(Appsignal).to receive(:active?).and_return(true)
@@ -12,188 +8,311 @@ if DependencyHelper.padrino_present?
       allow(Appsignal).to receive(:start_logger).and_return(true)
     end
 
-    describe "Appsignal::Integrations::PadrinoPlugin" do
-      it "should start the logger on init" do
-        expect(Appsignal).to receive(:start_logger)
+    describe Appsignal::Integrations::PadrinoPlugin do
+      it "starts AppSignal on init" do
+        expect(Appsignal).to receive(:start)
       end
 
-      it "should start appsignal on init" do
-        expect(Appsignal).to receive(:start)
+      it "starts the logger on init" do
+        expect(Appsignal).to receive(:start_logger)
       end
 
       context "when not active" do
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
-        it "should not add the Listener middleware to the stack" do
+        it "does not add the listener middleware to the stack" do
           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
+        it "uses 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 "uses the Padrino environment" do
           # Reset the plugin to pull down the latest data
           Appsignal::Integrations::PadrinoPlugin.init
 
-          expect(Appsignal.config.env).to eq Padrino.env.to_s
+          expect(Padrino.env.to_s).to eq("test")
+          expect(Appsignal.config.env).to eq(Padrino.env.to_s)
         end
       end
 
       after { Appsignal::Integrations::PadrinoPlugin.init }
     end
 
-    describe "Padrino::Routing::InstanceMethods" do
+    describe Padrino::Routing::InstanceMethods do
+      class PadrinoClassWithRouter
+        include Padrino::Routing
+      end
+
       let(:base)     { double }
-      let(:router)   { ClassWithRouter.new }
+      let(:router)   { PadrinoClassWithRouter.new }
       let(:env)      { {} }
       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",
-            :env             => {}
-          )
+      describe "routes" do
+        let(:transaction) do
+          instance_double "Appsignal::Transaction",
+            :set_http_or_background_action => nil,
+            :set_http_or_background_queue_start => nil,
+            :set_metadata => nil,
+            :set_action => nil,
+            :set_action_if_nil => nil,
+            :set_error => nil,
+            :start_event => nil,
+            :finish_event => nil,
+            :complete => nil
         end
-
+        let(:request_kind) { kind_of(Sinatra::Request) }
+        let(:env) do
+          {
+            "REQUEST_METHOD" => "GET",
+            "PATH_INFO" => path,
+            "REQUEST_PATH" => path,
+            "rack.input" => StringIO.new
+          }
+        end
+        let(:app) do
+          Class.new(Padrino::Application) do
+            def self.name
+              "PadrinoTestApp"
+            end
+          end
+        end
+        let(:response) { app.call(env) }
         before do
-          allow(router).to receive(:route_without_appsignal).and_return(true)
-          allow(router).to receive(:request).and_return(request)
-          allow(router).to receive(:env).and_return(env)
-          allow(router).to receive(:settings).and_return(settings)
-          allow(router).to receive(:get_payload_action).and_return("controller#action")
+          allow(Appsignal::Transaction).to receive(:create).and_return(transaction)
+          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
         end
 
-        context "when Sinatra tells us it's a static file" do
-          let(:env) { { "sinatra.static_file" => true } }
-
-          it "should call the original method" do
-            expect(router).to receive(:route_without_appsignal)
+        RSpec::Matchers.define :match_response do |expected_status, expected_content|
+          match do |response|
+            status, _headers, content = response
+            status == expected_status && content == [expected_content].compact
           end
+        end
 
-          it "should not instrument the request" do
-            expect(Appsignal).to_not receive(:instrument)
-          end
+        def expect_a_transaction_to_be_created
+          expect(Appsignal::Transaction).to receive(:create).with(
+            kind_of(String),
+            Appsignal::Transaction::HTTP_REQUEST,
+            request_kind
+          ).and_return(transaction)
+          expect(Appsignal).to receive(:instrument)
+            .at_least(:once)
+            .with("process_action.padrino")
+            .and_call_original
+          expect(transaction).to receive(:set_metadata).with("path", path)
+          expect(transaction).to receive(:set_metadata).with("method", "GET")
+          expect(transaction).to receive(:complete)
+        end
 
-          after { router.route!(base) }
+        def expect_no_transaction_to_be_created
+          expect(Appsignal::Transaction).to_not receive(:create)
+          expect(Appsignal).to_not receive(:instrument)
         end
 
-        context "when appsignal is not active" do
+        context "when AppSignal is not active" do
           before { allow(Appsignal).to receive(:active?).and_return(false) }
+          let(:path) { "/foo" }
+          before { app.controllers { get(:foo) { "content" } } }
+          after { expect(response).to match_response(200, "content") }
 
-          it "should call the original method" do
-            expect(router).to receive(:route_without_appsignal)
-          end
-
-          it "should not instrument the request" do
-            expect(Appsignal).to_not receive(:instrument)
+          it "does not instrument the request" do
+            expect_no_transaction_to_be_created
           end
-
-          after { router.route!(base) }
         end
 
-        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
-            )
-          end
-          before { allow(Appsignal::Transaction).to receive(:create).and_return(transaction) }
-
-          context "without an error" do
-            it "should create a transaction" do
-              expect(Appsignal::Transaction).to receive(:create).with(
-                kind_of(String),
-                Appsignal::Transaction::HTTP_REQUEST,
-                request
-              ).and_return(transaction)
-            end
-
-            it "should call the original routing method" do
-              expect(router).to receive(:route_without_appsignal)
-            end
+        context "when AppSignal is active" do
+          context "with not existing route" do
+            let(:path) { "/404" }
 
-            it "should instrument the action" do
-              expect(Appsignal).to receive(:instrument).with("process_action.padrino")
+            it "instruments the request" do
+              expect_a_transaction_to_be_created
+              # Uses path for action name
+              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#/404")
+              expect(response).to match_response(404, "<h1>Not Found</h1>")
             end
+          end
 
-            it "should set metadata" do
-              expect(transaction).to receive(:set_metadata).twice
+          context "when Sinatra tells us it's a static file" do
+            let(:path) { "/static" }
+            before do
+              env["sinatra.static_file"] = true
+              expect_any_instance_of(app)
+                .to receive(:route_without_appsignal).and_return([200, {}, ["foo"]])
             end
+            after { expect(response).to match_response(200, "foo") }
 
-            it "should set the action on the transaction" do
-              expect(transaction).to receive(:set_action).with("controller#action")
+            it "does not instrument the request" do
+              expect_no_transaction_to_be_created
             end
-
-            after { router.route!(base) }
           end
 
-          context "with an error" do
-            let(:error) { VerySpecificError.new }
-            before { allow(router).to receive(:route_without_appsignal).and_raise(error) }
-
-            it "should add the exception to the current transaction" do
-              expect(transaction).to receive(:set_error).with(error)
-
-              router.route!(base) rescue VerySpecificError
+          # Older Padrino versions don't support `action` (v11.0+)
+          context "without #action on Sinatra::Request" do
+            let(:path) { "/my_original_path" }
+            let(:request_kind) do
+              double(
+                :params => {},
+                :path => path,
+                :path_info => path,
+                :request_method => "GET",
+                :head? => false,
+                :route_obj => double(:original_path => "original_path method"),
+                :route_obj= => nil # Make sure route_obj doesn't get overwritten
+              )
             end
-          end
-        end
-      end
-
-      describe "#get_payload_action" do
-        before { allow(router).to receive(:settings).and_return(settings) }
-
-        context "when request is nil" do
-          it "should return the site" do
-            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") }
+            before do
+              expect(Sinatra::Request).to receive(:new).and_return(request_kind)
+              app.controllers { get(:my_original_path) { "content" } }
+            end
+            after { expect(response).to match_response(200, "content") }
 
-          it "should return the site name, controller and action" do
-            expect(router.get_payload_action(request)).to eql("TestApp:Controller#action")
+            it "falls back on Sinatra::Request#route_obj.original_path" do
+              expect_a_transaction_to_be_created
+              expect(transaction)
+                .to receive(:set_action_if_nil).with("PadrinoTestApp:original_path method")
+            end
           end
 
-          context "when there's no action" do
-            let(:request) { double(:controller => "Controller", :fullpath => "/action") }
+          context "without Sinatra::Request#route_obj.original_path" do
+            let(:path) { "/my_original_path" }
+            let(:request_kind) do
+              double(
+                :params => {},
+                :path => path,
+                :path_info => path,
+                :request_method => "GET",
+                :head? => false,
+                :route_obj= => nil # Make sure route_obj doesn't get overwritten
+              )
+            end
+            before do
+              expect(Sinatra::Request).to receive(:new).and_return(request_kind)
+              app.controllers { get(:my_original_path) { "content" } }
+            end
+            after { expect(response).to match_response(200, "content") }
 
-            it "should return the site name, controller and fullpath" do
-              expect(router.get_payload_action(request)).to eql("TestApp:Controller#/action")
+            it "falls back on app name" do
+              expect_a_transaction_to_be_created
+              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp")
             end
           end
-        end
 
-        context "when request has a route object" do
-          let(:request)      { double }
-          let(:route_object) { double(:original_path => "/accounts/edit/:id") }
-          before             { allow(request).to receive(:route_obj).and_return(route_object) }
+          context "with existing route" do
+            context "with an exception in the controller" do
+              let(:path) { "/exception" }
+              before do
+                app.controllers { get(:exception) { raise VerySpecificError } }
+                expect_a_transaction_to_be_created
+              end
+              after do
+                expect { response }.to raise_error(VerySpecificError)
+              end
+
+              it "sets the action name based on the app name and action name" do
+                expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#exception")
+              end
+
+              it "sets the error on the transaction" do
+                expect(transaction).to receive(:set_error).with(VerySpecificError)
+              end
+            end
 
-          it "should return the original path" do
-            expect(router.get_payload_action(request)).to eql("TestApp:/accounts/edit/:id")
+            context "without an exception in the controller" do
+              let(:path) { "/" }
+              after { expect(response).to match_response(200, "content") }
+
+              context "with action name as symbol" do
+                context "with :index helper" do
+                  before do
+                    # :index == "/"
+                    app.controllers { get(:index) { "content" } }
+                  end
+
+                  it "sets the action with the app name and action name" do
+                    expect_a_transaction_to_be_created
+                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#index")
+                  end
+                end
+
+                context "with custom action name" do
+                  let(:path) { "/foo" }
+                  before do
+                    app.controllers { get(:foo) { "content" } }
+                  end
+
+                  it "sets the action with the app name and action name" do
+                    expect_a_transaction_to_be_created
+                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#foo")
+                  end
+                end
+              end
+
+              context "with an action defined with a path" do
+                context "with root path" do
+                  before do
+                    # :index == "/"
+                    app.controllers { get("/") { "content" } }
+                  end
+
+                  it "sets the action with the app name and action path" do
+                    expect_a_transaction_to_be_created
+                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#/")
+                  end
+                end
+
+                context "with custom path" do
+                  let(:path) { "/foo" }
+                  before do
+                    app.controllers { get("/foo") { "content" } }
+                  end
+
+                  it "sets the action with the app name and action path" do
+                    expect_a_transaction_to_be_created
+                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:#/foo")
+                  end
+                end
+              end
+
+              context "with controller" do
+                let(:path) { "/my_controller" }
+
+                context "with controller as name" do
+                  before do
+                    # :index == "/"
+                    app.controllers(:my_controller) { get(:index) { "content" } }
+                  end
+
+                  it "sets the action with the app name, controller name and action name" do
+                    expect_a_transaction_to_be_created
+                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:my_controller#index")
+                  end
+                end
+
+                context "with controller as path" do
+                  before do
+                    # :index == "/"
+                    app.controllers("/my_controller") { get(:index) { "content" } }
+                  end
+
+                  it "sets the action with the app name, controller name and action path" do
+                    expect_a_transaction_to_be_created
+                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:/my_controller#index")
+                  end
+                end
+              end
+            end
           end
         end
       end