appsignal 4.0.5 → 4.0.7

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

@@ -1,154 +0,0 @@
-require "appsignal/integrations/mongo_ruby_driver"
-describe Appsignal::Hooks::MongoMonitorSubscriber do
-  let(:subscriber) { Appsignal::Hooks::MongoMonitorSubscriber.new }
-
-  context "with transaction" do
-    let(:transaction) { http_request_transaction }
-    before do
-      start_agent
-      set_current_transaction(transaction)
-    end
-
-    describe "#started" do
-      let(:event) do
-        double(
-          :request_id   => 1,
-          :command_name => "find",
-          :command      => { "foo" => "bar" }
-        )
-      end
-
-      it "should sanitize command" do
-        # TODO: additional curly brackets required for issue
-        # https://github.com/rspec/rspec-mocks/issues/1460
-        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",
-          :duration      => 0.9919
-        )
-      end
-
-      before do
-        store = transaction.store("mongo_driver")
-        store[2] = command
-      end
-
-      it "should emit a measurement" do
-        expect(Appsignal).to receive(:add_distribution_value).with(
-          "mongodb_query_duration",
-          0.9919,
-          :database => "test"
-        ).and_call_original
-
-        subscriber.finish("SUCCEEDED", event)
-      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
-
-    it "should not attempt to send duration metrics" do
-      expect(Appsignal).to_not receive(:add_distribution_value)
-
-      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
-
-    it "should not attempt to send duration metrics" do
-      expect(Appsignal).to_not receive(:add_distribution_value)
-
-      subscriber.finish("SUCCEEDED", double)
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require "appsignal/integrations/net_http"
-
-describe Appsignal::Integrations::NetHttpIntegration do
-  let(:transaction) { http_request_transaction }
-  before { start_agent }
-  before { set_current_transaction transaction }
-  around { |example| keep_transactions { example.run } }
-
-  it "instruments a http request" do
-    stub_request(:any, "http://www.google.com/")
-
-    Net::HTTP.get_response(URI.parse("http://www.google.com"))
-
-    expect(transaction).to include_event(
-      "name" => "request.net_http",
-      "title" => "GET http://www.google.com"
-    )
-  end
-
-  it "instruments a https request" do
-    stub_request(:any, "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)
-
-    expect(transaction).to include_event(
-      "name" => "request.net_http",
-      "title" => "GET https://www.google.com"
-    )
-  end
-end

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

@@ -1,347 +0,0 @@
-require "appsignal/integrations/object"
-
-describe Object do
-  around { |example| keep_transactions { example.run } }
-
-  describe "#instrument_method" do
-    context "with instance method" do
-      let(:klass) do
-        Class.new do
-          def foo(param1, options = {}, keyword_param: 1)
-            [param1, options, keyword_param]
-          end
-          appsignal_instrument_method :foo
-        end
-      end
-      let(:instance) { klass.new }
-
-      def call_with_arguments
-        instance.foo(
-          "abc",
-          { :foo => "bar" },
-          :keyword_param => 2
-        )
-      end
-
-      context "when active" do
-        let(:transaction) { http_request_transaction }
-        before do
-          start_agent
-          set_current_transaction(transaction)
-        end
-
-        context "with different kind of arguments" do
-          let(:klass) do
-            Class.new do
-              def positional_arguments(param1, param2)
-                [param1, param2]
-              end
-              appsignal_instrument_method :positional_arguments
-
-              def positional_arguments_splat(*params)
-                params
-              end
-              appsignal_instrument_method :positional_arguments_splat
-
-              # rubocop:disable Naming/MethodParameterName
-              def keyword_arguments(a: nil, b: nil)
-                [a, b]
-              end
-              # rubocop:enable Naming/MethodParameterName
-              appsignal_instrument_method :keyword_arguments
-
-              def keyword_arguments_splat(**kwargs)
-                kwargs
-              end
-              appsignal_instrument_method :keyword_arguments_splat
-
-              def splat(*args, **kwargs)
-                [args, kwargs]
-              end
-              appsignal_instrument_method :splat
-            end
-          end
-
-          it "instruments the method and calls it" do
-            expect(instance.positional_arguments("abc", "def")).to eq(["abc", "def"])
-            expect(instance.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
-            expect(instance.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
-            expect(instance.keyword_arguments_splat(:a => "a", :b => "b"))
-              .to eq(:a => "a", :b => "b")
-
-            expect(instance.splat).to eq([[], {}])
-            expect(instance.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
-            expect(instance.splat("abc", "def")).to eq([["abc", "def"], {}])
-            expect(instance.splat("abc", "def", :a => "a", :b => "b"))
-              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
-          end
-        end
-
-        context "with anonymous class" do
-          it "instruments the method and calls it" do
-            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
-
-            expect(transaction).to include_event("name" => "foo.AnonymousClass.other")
-          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(instance.foo).to eq(1)
-
-            expect(transaction).to include_event("name" => "foo.NamedClass.other")
-          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(instance.bar).to eq(2)
-
-            expect(transaction).to include_event(
-              "name" => "bar.NamedClass.NestedModule.MyModule.other"
-            )
-          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(instance.foo).to eq(1)
-
-            expect(transaction).to include_event(
-              "name" => "my_method.group"
-            )
-          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 "yields the block" do
-            expect(instance.foo { 42 }).to eq(42)
-          end
-        end
-      end
-
-      context "when not active" do
-        let(:transaction) { Appsignal::Transaction.current }
-
-        it "does not instrument, but still calls the method" do
-          expect(Appsignal.active?).to be_falsy
-          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
-        end
-      end
-    end
-
-    context "with class method" do
-      let(:klass) do
-        Class.new do
-          def self.bar(param1, options = {}, keyword_param: 1)
-            [param1, options, keyword_param]
-          end
-          appsignal_instrument_class_method :bar
-        end
-      end
-      def call_with_arguments
-        klass.bar(
-          "abc",
-          { :foo => "bar" },
-          :keyword_param => 2
-        )
-      end
-
-      context "when active" do
-        let(:transaction) { http_request_transaction }
-        before do
-          start_agent
-          set_current_transaction(transaction)
-        end
-
-        context "with different kind of arguments" do
-          let(:klass) do
-            Class.new do
-              def self.positional_arguments(param1, param2)
-                [param1, param2]
-              end
-              appsignal_instrument_class_method :positional_arguments
-
-              def self.positional_arguments_splat(*params)
-                params
-              end
-              appsignal_instrument_class_method :positional_arguments_splat
-
-              # rubocop:disable Naming/MethodParameterName
-              def self.keyword_arguments(a: nil, b: nil)
-                [a, b]
-              end
-              # rubocop:enable Naming/MethodParameterName
-              appsignal_instrument_class_method :keyword_arguments
-
-              def self.keyword_arguments_splat(**kwargs)
-                kwargs
-              end
-              appsignal_instrument_class_method :keyword_arguments_splat
-
-              def self.splat(*args, **kwargs)
-                [args, kwargs]
-              end
-              appsignal_instrument_class_method :splat
-            end
-          end
-
-          it "instruments the method and calls it" do
-            expect(klass.positional_arguments("abc", "def")).to eq(["abc", "def"])
-            expect(klass.positional_arguments_splat("abc", "def")).to eq(["abc", "def"])
-            expect(klass.keyword_arguments(:a => "a", :b => "b")).to eq(["a", "b"])
-            expect(klass.keyword_arguments_splat(:a => "a", :b => "b"))
-              .to eq(:a => "a", :b => "b")
-
-            expect(klass.splat).to eq([[], {}])
-            expect(klass.splat(:a => "a", :b => "b")).to eq([[], { :a => "a", :b => "b" }])
-            expect(klass.splat("abc", "def")).to eq([["abc", "def"], {}])
-            expect(klass.splat("abc", "def", :a => "a", :b => "b"))
-              .to eq([["abc", "def"], { :a => "a", :b => "b" }])
-          end
-        end
-
-        context "with anonymous class" do
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
-
-            transaction._sample
-            expect(transaction).to include_event("name" => "bar.class_method.AnonymousClass.other")
-          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(klass.bar).to eq(2)
-
-            expect(transaction).to include_event("name" => "bar.class_method.NamedClass.other")
-          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(klass.bar).to eq(2)
-              expect(transaction).to include_event(
-                "name" => "bar.class_method.NamedClass.NestedModule.MyModule.other"
-              )
-            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(klass.bar).to eq(2)
-
-            expect(transaction).to include_event("name" => "my_method.group")
-          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 "yields the block" do
-            expect(klass.bar { 42 }).to eq(42)
-          end
-        end
-      end
-
-      context "when not active" do
-        let(:transaction) { Appsignal::Transaction.current }
-
-        it "does not instrument, but still call the method" do
-          expect(Appsignal.active?).to be_falsy
-          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }, 2])
-        end
-      end
-    end
-  end
-end

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

@@ -1,150 +0,0 @@
-require "appsignal/integrations/puma"
-
-describe Appsignal::Integrations::PumaServer do
-  describe "#lowlevel_error" do
-    before do
-      stub_const("Puma", PumaMock)
-      stub_const("Puma::Server", puma_server)
-      start_agent
-    end
-    let(:queue_start_time) { fixed_time * 1_000 }
-    let(:env) do
-      Rack::MockRequest.env_for(
-        "/some/path",
-        "REQUEST_METHOD" => "GET",
-        :params => { "page" => 2, "query" => "lorem" },
-        "rack.session" => { "session" => "data", "user_id" => 123 },
-        "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}" # in milliseconds
-      )
-    end
-    let(:server) { Puma::Server.new }
-    let(:error) { ExampleException.new("error message") }
-    around { |example| keep_transactions { example.run } }
-    before { Appsignal::Hooks::PumaHook.new.install }
-
-    def lowlevel_error(error, env, status = nil)
-      result =
-        if status
-          server.lowlevel_error(error, env, status)
-        else
-          server.lowlevel_error(error, env)
-        end
-      # Transaction is normally closed by the EventHandler's RACK_AFTER_REPLY hook
-      last_transaction&.complete
-      result
-    end
-
-    describe "error reporting" do
-      let(:puma_server) { default_puma_server_mock }
-
-      context "with active transaction" do
-        before { create_transaction }
-
-        it "reports the error to the transaction" do
-          expect do
-            lowlevel_error(error, env)
-          end.to_not(change { created_transactions.count })
-
-          expect(last_transaction).to have_error("ExampleException", "error message")
-          expect(last_transaction).to include_tags("reported_by" => "puma_lowlevel_error")
-        end
-      end
-
-      # This shouldn't happen if the EventHandler is set up correctly, but if
-      # it's not it will create a new transaction.
-      context "without active transaction" do
-        it "creates a new transaction with the error" do
-          expect do
-            lowlevel_error(error, env)
-          end.to change { created_transactions.count }.by(1)
-
-          expect(last_transaction).to have_error("ExampleException", "error message")
-          expect(last_transaction).to include_tags("reported_by" => "puma_lowlevel_error")
-        end
-      end
-
-      it "doesn't report internal Puma errors" do
-        expect do
-          lowlevel_error(Puma::MiniSSL::SSLError.new("error message"), env)
-          lowlevel_error(Puma::HttpParserError.new("error message"), env)
-          lowlevel_error(Puma::HttpParserError501.new("error message"), env)
-        end.to_not(change { created_transactions.count })
-      end
-
-      describe "request metadata" do
-        it "sets request metadata" do
-          lowlevel_error(error, env)
-
-          expect(last_transaction).to include_metadata(
-            "request_method" => "GET",
-            "method" => "GET",
-            "request_path" => "/some/path",
-            "path" => "/some/path"
-          )
-          expect(last_transaction).to include_environment(
-            "REQUEST_METHOD" => "GET",
-            "PATH_INFO" => "/some/path"
-            # and more, but we don't need to test Rack mock defaults
-          )
-        end
-
-        it "sets request parameters" do
-          lowlevel_error(error, env)
-
-          expect(last_transaction).to include_params(
-            "page" => "2",
-            "query" => "lorem"
-          )
-        end
-
-        it "sets session data" do
-          lowlevel_error(error, env)
-
-          expect(last_transaction).to include_session_data("session" => "data", "user_id" => 123)
-        end
-
-        it "sets the queue start" do
-          lowlevel_error(error, env)
-
-          expect(last_transaction).to have_queue_start(queue_start_time)
-        end
-      end
-    end
-
-    context "with Puma::Server#lowlevel_error accepting 3 arguments" do
-      let(:puma_server) { default_puma_server_mock }
-
-      it "calls the super class with 3 arguments" do
-        result = lowlevel_error(error, env, 501)
-        expect(result).to eq([501, {}, ""])
-
-        expect(last_transaction).to include_tags("response_status" => 501)
-      end
-    end
-
-    context "with Puma::Server#lowlevel_error accepting 2 arguments" do
-      let(:puma_server) do
-        Class.new do
-          def lowlevel_error(_error, _env)
-            [500, {}, ""]
-          end
-        end
-      end
-
-      it "calls the super class with 3 arguments" do
-        result = lowlevel_error(error, env)
-        expect(result).to eq([500, {}, ""])
-
-        expect(last_transaction).to include_tags("response_status" => 500)
-      end
-    end
-  end
-
-  def default_puma_server_mock
-    Class.new do
-      def lowlevel_error(_error, _env, status = 500)
-        [status, {}, ""]
-      end
-    end
-  end
-end