appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,127 @@
+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", {}, {})
+    end
+
+    describe "#started" do
+      let(:event) do
+        double(
+          :request_id   => 1,
+          :command_name => "find",
+          :command      => { "foo" => "bar" }
+        )
+      end
+
+      it "should sanitize command" do
+        expect(Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter)
+          .to receive(:format).with("find", "foo" => "bar")
+
+        subscriber.started(event)
+      end
+
+      it "should store command on the transaction" do
+        subscriber.started(event)
+
+        expect(transaction.store("mongo_driver")).to eq(1 => { "foo" => "?" })
+      end
+
+      it "should start an event in the extension" do
+        expect(transaction).to receive(:start_event)
+
+        subscriber.started(event)
+      end
+    end
+
+    describe "#succeeded" do
+      let(:event) { double }
+
+      it "should finish the event" do
+        expect(subscriber).to receive(:finish).with("SUCCEEDED", event)
+
+        subscriber.succeeded(event)
+      end
+    end
+
+    describe "#failed" do
+      let(:event) { double }
+
+      it "should finish the event" do
+        expect(subscriber).to receive(:finish).with("FAILED", event)
+
+        subscriber.failed(event)
+      end
+    end
+
+    describe "#finish" do
+      let(:command) { { "foo" => "?" } }
+      let(:event) do
+        double(
+          :request_id    => 2,
+          :command_name  => :find,
+          :database_name => "test"
+        )
+      end
+
+      before do
+        store = transaction.store("mongo_driver")
+        store[2] = command
+      end
+
+      it "should get the query from the store" do
+        expect(transaction).to receive(:store).with("mongo_driver").and_return(command)
+
+        subscriber.finish("SUCCEEDED", event)
+      end
+
+      it "should finish the transaction in the extension" do
+        expect(transaction).to receive(:finish_event).with(
+          "query.mongodb",
+          "find | test | SUCCEEDED",
+          Appsignal::Utils.data_generate("foo" => "?"),
+          0
+        )
+
+        subscriber.finish("SUCCEEDED", event)
+      end
+    end
+  end
+
+  context "without transaction" do
+    before do
+      allow(Appsignal::Transaction).to receive(:current).and_return(Appsignal::Transaction::NilTransaction.new)
+    end
+
+    it "should not attempt to start an event" do
+      expect(Appsignal::Extension).to_not receive(:start_event)
+
+      subscriber.started(double)
+    end
+
+    it "should not attempt to finish an event" do
+      expect(Appsignal::Extension).to_not receive(:finish_event)
+
+      subscriber.finish("SUCCEEDED", double)
+    end
+  end
+
+  context "when appsignal is paused" do
+    let(:transaction) { double(:paused? => true, :nil_transaction? => false) }
+    before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
+
+    it "should not attempt to start an event" do
+      expect(Appsignal::Extension).to_not receive(:start_event)
+
+      subscriber.started(double)
+    end
+
+    it "should not attempt to finish an event" do
+      expect(Appsignal::Extension).to_not receive(:finish_event)
+
+      subscriber.finish("SUCCEEDED", double)
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+require "appsignal/integrations/object"
+
+describe Object do
+  describe "#instrument_method" do
+    context "with instance method" do
+      let(:klass) do
+        Class.new do
+          def foo
+            1
+          end
+          appsignal_instrument_method :foo
+        end
+      end
+      let(:instance) { klass.new }
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+          Appsignal.config = project_fixture_config
+        end
+        after { Appsignal.config = nil }
+
+        context "with anonymous class" do
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          let(:klass) { NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with nested named class" do
+          before do
+            module MyModule
+              module NestedModule
+                class NamedClass
+                  def bar
+                    2
+                  end
+                  appsignal_instrument_method :bar
+                end
+              end
+            end
+          end
+          after { Object.send(:remove_const, :MyModule) }
+          let(:klass) { MyModule::NestedModule::NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
+              Appsignal::EventFormatter::DEFAULT
+            expect(instance.bar).to eq(2)
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo, :name => "my_method.group"
+            end
+          end
+
+          it "instruments with custom name" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def foo
+                yield
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+
+          it "should yield the block" do
+            expect(instance.foo { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "should not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(instance.foo).to eq(1)
+        end
+      end
+    end
+
+    context "with class method" do
+      let(:klass) do
+        Class.new do
+          def self.bar
+            2
+          end
+          appsignal_instrument_class_method :bar
+        end
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once)
+            .and_return(transaction)
+          Appsignal.config = project_fixture_config
+        end
+        after { Appsignal.config = nil }
+
+        context "with anonymous class" do
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          let(:klass) { NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+
+          context "with nested named class" do
+            before do
+              module MyModule
+                module NestedModule
+                  class NamedClass
+                    def self.bar
+                      2
+                    end
+                    appsignal_instrument_class_method :bar
+                  end
+                end
+              end
+            end
+            after { Object.send(:remove_const, :MyModule) }
+            let(:klass) { MyModule::NestedModule::NamedClass }
+
+            it "instruments the method and calls it" do
+              expect(Appsignal.active?).to be_truthy
+              expect(transaction).to receive(:start_event)
+              expect(transaction).to receive(:finish_event).with \
+                "bar.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
+                Appsignal::EventFormatter::DEFAULT
+              expect(klass.bar).to eq(2)
+            end
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar, :name => "my_method.group"
+            end
+          end
+
+          it "instruments with custom name" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                yield
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+
+          it "should yield the block" do
+            expect(klass.bar { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "should not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(klass.bar).to eq(2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,323 @@
+if DependencyHelper.padrino_present?
+  describe "Padrino integration" do
+    require "appsignal/integrations/padrino"
+
+    before do
+      allow(Appsignal).to receive(:active?).and_return(true)
+      allow(Appsignal).to receive(:start).and_return(true)
+      allow(Appsignal).to receive(:start_logger).and_return(true)
+    end
+
+    describe Appsignal::Integrations::PadrinoPlugin do
+      it "starts AppSignal on init" do
+        expect(Appsignal).to receive(:start)
+      end
+
+      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 "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 "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")
+        end
+      end
+
+      context "when APPSIGNAL_APP_ENV ENV var is not provided" do
+        it "uses the Padrino environment" do
+          # Reset the plugin to pull down the latest data
+          Appsignal::Integrations::PadrinoPlugin.init
+
+          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
+      class PadrinoClassWithRouter
+        include Padrino::Routing
+      end
+
+      let(:base)     { double }
+      let(:router)   { PadrinoClassWithRouter.new }
+      let(:env)      { {} }
+      # TODO: use an instance double
+      let(:settings) { double(:name => "TestApp") }
+
+      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(Appsignal::Transaction).to receive(:create).and_return(transaction)
+          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
+        end
+
+        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
+
+        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
+
+        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
+          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 "does not instrument the request" do
+            expect_no_transaction_to_be_created
+          end
+        end
+
+        context "when AppSignal is active" do
+          context "with not existing route" do
+            let(:path) { "/404" }
+
+            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
+
+          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 "does not instrument the request" do
+              expect_no_transaction_to_be_created
+            end
+          end
+
+          # 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
+            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 "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 "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 "falls back on app name" do
+              expect_a_transaction_to_be_created
+              expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp")
+            end
+          end
+
+          context "with existing route" do
+            context "with an exception in the controller" do
+              let(:path) { "/exception" }
+              before do
+                app.controllers { get(:exception) { raise ExampleException } }
+                expect_a_transaction_to_be_created
+              end
+              after do
+                expect { response }.to raise_error(ExampleException)
+              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(ExampleException)
+              end
+            end
+
+            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
+    end
+  end
+end