appsignal 4.0.6-java → 4.0.8-java

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

@@ -1,80 +0,0 @@
-describe Appsignal::Hooks::PumaHook do
-  context "with puma" do
-    let(:puma_version) { "6.0.0" }
-    before do
-      stub_const("Puma", PumaMock)
-      stub_const("Puma::Const::VERSION", puma_version)
-    end
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      context "when Puma present" do
-        context "when Puma is newer than version 3.0.0" do
-          let(:puma_version) { "3.0.0" }
-
-          it { is_expected.to be_truthy }
-        end
-
-        context "when Puma is older than version 3.0.0" do
-          let(:puma_version) { "2.9.9" }
-
-          it { is_expected.to be_falsey }
-        end
-      end
-
-      context "when Puma is not present" do
-        before do
-          hide_const("Puma")
-        end
-
-        it { is_expected.to be_falsey }
-      end
-    end
-
-    describe "installation" do
-      before { Appsignal::Probes.probes.clear }
-
-      it "adds the Puma::Server patch" do
-        Appsignal::Hooks::PumaHook.new.install
-        expect(::Puma::Server.included_modules).to include(Appsignal::Integrations::PumaServer)
-      end
-
-      context "when not clustered mode" do
-        it "does not add AppSignal stop behavior Puma::Cluster" do
-          expect(defined?(::Puma::Cluster)).to be_falsy
-          # Does not error on call
-          Appsignal::Hooks::PumaHook.new.install
-        end
-      end
-
-      context "when in clustered mode" do
-        before do
-          stub_const("Puma::Cluster", Class.new do
-            def stop_workers
-              @called = true
-            end
-          end)
-        end
-
-        it "adds behavior to Puma::Cluster.stop_workers" do
-          Appsignal::Hooks::PumaHook.new.install
-          cluster = Puma::Cluster.new
-
-          expect(cluster.instance_variable_defined?(:@called)).to be_falsy
-          expect(Appsignal).to receive(:stop).and_call_original
-          cluster.stop_workers
-          expect(cluster.instance_variable_get(:@called)).to be(true)
-        end
-      end
-    end
-  end
-
-  context "without puma" 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/que_spec.rb

@@ -1,19 +0,0 @@
-describe Appsignal::Hooks::QueHook do
-  if DependencyHelper.que_present?
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    it "installs the QuePlugin" do
-      expect(Que::Job.included_modules).to include(Appsignal::Integrations::QuePlugin)
-    end
-  else
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,144 +0,0 @@
-require "rake"
-
-describe Appsignal::Hooks::RakeHook do
-  let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
-  let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
-  let(:arguments) { Rake::TaskArguments.new(["foo"], ["bar"]) }
-  let(:options) { {} }
-  before do
-    start_agent(:options => options)
-    allow(Kernel).to receive(:at_exit)
-  end
-  around { |example| keep_transactions { example.run } }
-  after do
-    if helper.instance_variable_defined?(:@register_at_exit_hook)
-      helper.remove_instance_variable(:@register_at_exit_hook)
-    end
-  end
-
-  def expect_to_not_have_registered_at_exit_hook
-    expect(Kernel).to_not have_received(:at_exit)
-  end
-
-  def expect_to_have_registered_at_exit_hook
-    expect(Kernel).to have_received(:at_exit)
-  end
-
-  describe "#execute" do
-    context "without error" do
-      def perform
-        task.execute(arguments)
-      end
-
-      context "with :enable_rake_performance_instrumentation == false" do
-        let(:options) { { :enable_rake_performance_instrumentation => false } }
-
-        it "creates no transaction" do
-          expect { perform }.to_not(change { created_transactions.count })
-        end
-
-        it "calls the original task" do
-          expect(perform).to eq([])
-        end
-
-        it "does not register an at_exit hook" do
-          perform
-          expect_to_not_have_registered_at_exit_hook
-        end
-      end
-
-      context "with :enable_rake_performance_instrumentation == true" do
-        let(:options) { { :enable_rake_performance_instrumentation => true } }
-
-        it "creates a transaction" do
-          expect { perform }.to(change { created_transactions.count }.by(1))
-
-          transaction = last_transaction
-          expect(transaction).to have_id
-          expect(transaction).to have_namespace("rake")
-          expect(transaction).to have_action("task:name")
-          expect(transaction).to_not have_error
-          expect(transaction).to include_params("foo" => "bar")
-          expect(transaction).to include_event("name" => "task.rake")
-          expect(transaction).to be_completed
-        end
-
-        it "calls the original task" do
-          expect(perform).to eq([])
-        end
-
-        it "registers an at_exit hook" do
-          perform
-          expect_to_have_registered_at_exit_hook
-        end
-      end
-    end
-
-    context "with error" do
-      before do
-        task.enhance { raise ExampleException, "error message" }
-      end
-
-      def perform
-        expect { task.execute(arguments) }.to raise_error(ExampleException, "error message")
-      end
-
-      it "creates a background job transaction" do
-        perform
-
-        transaction = last_transaction
-        expect(transaction).to have_id
-        expect(transaction).to have_namespace("rake")
-        expect(transaction).to have_action("task:name")
-        expect(transaction).to have_error("ExampleException", "error message")
-        expect(transaction).to include_params("foo" => "bar")
-        expect(transaction).to be_completed
-      end
-
-      it "registers an at_exit hook" do
-        perform
-        expect_to_have_registered_at_exit_hook
-      end
-
-      context "when first argument is not a `Rake::TaskArguments`" do
-        let(:arguments) { nil }
-
-        it "does not add the params to the transaction" do
-          perform
-
-          expect(last_transaction).to_not include_params
-        end
-      end
-    end
-  end
-end
-
-describe "Appsignal::Integrations::RakeIntegrationHelper" do
-  let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
-  describe ".register_at_exit_hook" do
-    before do
-      start_agent
-      allow(Appsignal).to receive(:stop)
-    end
-
-    it "registers the at_exit hook only once" do
-      allow(Kernel).to receive(:at_exit)
-      helper.register_at_exit_hook
-      helper.register_at_exit_hook
-      expect(Kernel).to have_received(:at_exit).once
-    end
-  end
-
-  describe ".at_exit_hook" do
-    let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
-    before do
-      start_agent
-      allow(Appsignal).to receive(:stop)
-    end
-
-    it "calls Appsignal.stop" do
-      helper.at_exit_hook
-      expect(Appsignal).to have_received(:stop).with("rake")
-    end
-  end
-end

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

@@ -1,218 +0,0 @@
-describe Appsignal::Hooks::RedisClientHook do
-  let(:options) { {} }
-  before do
-    start_agent(:options => options)
-  end
-
-  if DependencyHelper.redis_client_present?
-    context "with redis-client" do
-      context "with instrumentation enabled" do
-        describe "#dependencies_present?" do
-          subject { described_class.new.dependencies_present? }
-
-          context "with gem version new than 0.14.0" do
-            before { stub_const("RedisClient::VERSION", "1.2.3") }
-
-            it { is_expected.to be_truthy }
-          end
-
-          context "with gem version 0.14.0" do
-            before { stub_const("RedisClient::VERSION", "0.14.0") }
-
-            it { is_expected.to be_truthy }
-          end
-
-          context "with gem version older than 0.14.0" do
-            before { stub_const("RedisClient::VERSION", "0.13.9") }
-
-            it { is_expected.to be_falsy }
-          end
-        end
-
-        context "with rest-client gem" do
-          describe "integration" do
-            let(:options) { { :instrument_redis => true } }
-
-            context "install" do
-              before do
-                Appsignal::Hooks.load_hooks
-              end
-
-              it "includes the integration for the ruby connection" do
-                # Test if the last included module (prepended module) was our
-                # integration. That's not certain with the assertions below
-                # because we have to overwrite the `process` method for the test.
-                expect(RedisClient::RubyConnection.included_modules.first)
-                  .to eql(Appsignal::Integrations::RedisClientIntegration)
-              end
-            end
-
-            context "requirements" do
-              it "driver should have the write method" do
-                # Since we stub the driver class below, to make sure that we don't
-                # create a real connection, the test won't fail if the method definition
-                # is changed.
-                method = RedisClient::RubyConnection.instance_method(:write)
-                expect(method.arity).to eql(1)
-              end
-            end
-
-            context "instrumentation" do
-              before do
-                start_agent
-                # Stub RedisClient::RubyConnection class so that it doesn't perform an actual
-                # Redis query. This class will be included (prepended) with the
-                # AppSignal Redis integration.
-                stub_const("RedisClient::RubyConnection", Class.new do
-                  def initialize(config)
-                    @config = config
-                  end
-
-                  def write(_commands)
-                    "stub_write"
-                  end
-                end)
-                # Load the integration again for the stubbed RedisClient::RubyConnection class.
-                # Call it directly because {Appsignal::Hooks.load_hooks} keeps
-                # track if it was installed already or not.
-                Appsignal::Hooks::RedisClientHook.new.install
-              end
-              let(:transaction) { http_request_transaction }
-              let!(:client_config) { RedisClient::Config.new(:id => "stub_id") }
-              before { set_current_transaction(transaction) }
-              around { |example| keep_transactions { example.run } }
-
-              it "instrument a redis call" do
-                connection = RedisClient::RubyConnection.new client_config
-                expect(connection.write([:get, "key"])).to eql("stub_write")
-
-                expect(transaction).to include_event(
-                  "name" => "query.redis",
-                  "body" => "get ?",
-                  "title" => "stub_id"
-                )
-              end
-
-              it "instrument a redis script call" do
-                connection = ::RedisClient::RubyConnection.new client_config
-                script = "return redis.call('set',KEYS[1],ARGV[1])"
-                keys = ["foo"]
-                argv = ["bar"]
-                expect(connection.write([:eval, script, keys.size, keys, argv]))
-                  .to eql("stub_write")
-
-                expect(transaction).to include_event(
-                  "name" => "query.redis",
-                  "body" => "#{script} ? ?",
-                  "title" => "stub_id"
-                )
-              end
-            end
-          end
-        end
-
-        if DependencyHelper.hiredis_client_present?
-          context "with hiredis driver" do
-            describe "integration" do
-              let(:options) { { :instrument_redis => true } }
-
-              context "install" do
-                before do
-                  Appsignal::Hooks.load_hooks
-                end
-
-                it "includes the integration in the HiredisConnection class" do
-                  # Test if the last included module (prepended module) was our
-                  # integration. That's not certain with the assertions below
-                  # because we have to overwrite the `process` method for the test.
-                  expect(RedisClient::HiredisConnection.included_modules.first)
-                    .to eql(Appsignal::Integrations::RedisClientIntegration)
-                end
-              end
-
-              context "requirements" do
-                it "driver should have the write method" do
-                  # Since we stub the driver class below, to make sure that we don't
-                  # create a real connection, the test won't fail if the method definition
-                  # is changed.
-                  method = RedisClient::HiredisConnection.instance_method(:write)
-                  expect(method.arity).to eql(1)
-                end
-              end
-
-              context "instrumentation" do
-                before do
-                  start_agent
-                  # Stub RedisClient::HiredisConnection class so that it doesn't perform an actual
-                  # Redis query. This class will be included (prepended) with the
-                  # AppSignal Redis integration.
-                  stub_const("RedisClient::HiredisConnection", Class.new do
-                    def initialize(config)
-                      @config = config
-                    end
-
-                    def write(_commands)
-                      "stub_write"
-                    end
-                  end)
-                  # Load the integration again for the stubbed RedisClient::HiredisConnection class.
-                  # Call it directly because {Appsignal::Hooks.load_hooks} keeps
-                  # track if it was installed already or not.
-                  Appsignal::Hooks::RedisClientHook.new.install
-                end
-                let(:transaction) { http_request_transaction }
-                let!(:client_config) { RedisClient::Config.new(:id => "stub_id") }
-                before { set_current_transaction(transaction) }
-                around { |example| keep_transactions { example.run } }
-
-                it "instrument a redis call" do
-                  connection = RedisClient::HiredisConnection.new client_config
-                  expect(connection.write([:get, "key"])).to eql("stub_write")
-
-                  expect(transaction).to include_event(
-                    "name" => "query.redis",
-                    "body" => "get ?",
-                    "title" => "stub_id"
-                  )
-                end
-
-                it "instrument a redis script call" do
-                  connection = ::RedisClient::HiredisConnection.new client_config
-                  script = "return redis.call('set',KEYS[1],ARGV[1])"
-                  keys = ["foo"]
-                  argv = ["bar"]
-                  expect(connection.write([:eval, script, keys.size, keys,
-                                           argv])).to eql("stub_write")
-
-                  expect(transaction).to include_event(
-                    "name" => "query.redis",
-                    "body" => "#{script} ? ?",
-                    "title" => "stub_id"
-                  )
-                end
-              end
-            end
-          end
-        end
-      end
-
-      context "with instrumentation disabled" do
-        let(:options) { { :instrument_redis => false } }
-
-        describe "#dependencies_present?" do
-          subject { described_class.new.dependencies_present? }
-
-          it { is_expected.to be_falsy }
-        end
-      end
-    end
-  else
-    context "without redis-client" do
-      describe "#dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
-
-        it { is_expected.to be_falsy }
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-describe Appsignal::Hooks::RedisHook do
-  let(:options) { {} }
-  before { start_agent(:options => options) }
-
-  if DependencyHelper.redis_present?
-    context "with redis" do
-      if DependencyHelper.redis_client_present?
-        context "with redis-client" do
-          context "with instrumentation enabled" do
-            describe "#dependencies_present?" do
-              subject { described_class.new.dependencies_present? }
-
-              it { is_expected.to be_falsey }
-            end
-          end
-        end
-      else
-        context "with instrumentation enabled" do
-          describe "#dependencies_present?" do
-            subject { described_class.new.dependencies_present? }
-
-            it { is_expected.to be_truthy }
-          end
-
-          describe "integration" do
-            let(:options) { { :instrument_redis => true } }
-
-            context "install" do
-              before do
-                Appsignal::Hooks.load_hooks
-              end
-
-              it "prepends instrumentation module" do
-                # Test if the last included module (prepended module) was our
-                # integration. That's not certain with the assertions below
-                # because we have to overwrite the `process` method for the test.
-                expect(Redis::Client.included_modules.first)
-                  .to eql(Appsignal::Integrations::RedisIntegration)
-              end
-            end
-
-            context "requirements" do
-              it "driver should have the write method" do
-                # Since we stub the client class below, to make sure that we don't
-                # create a real connection, the test won't fail if the method definition
-                # is changed.
-                method = Redis::Client.instance_method(:call)
-                expect(method.arity).to eql(1)
-              end
-            end
-
-            context "instrumentation" do
-              before do
-                start_agent
-                # Stub Redis::Client class so that it doesn't perform an actual
-                # Redis query. This class will be included (prepended) with the
-                # AppSignal Redis integration.
-                stub_const("Redis::Client", Class.new do
-                  def id
-                    "stub_id"
-                  end
-
-                  def write(_commands)
-                    "stub_write"
-                  end
-                end)
-                # Load the integration again for the stubbed Redis::Client class.
-                # Call it directly because {Appsignal::Hooks.load_hooks} keeps
-                # track if it was installed already or not.
-                Appsignal::Hooks::RedisHook.new.install
-              end
-              let(:transaction) { http_request_transaction }
-              before { set_current_transaction(transaction) }
-              around { |example| keep_transactions { example.run } }
-
-              it "instrument a redis call" do
-                client = Redis::Client.new
-                expect(client.write([:get, "key"])).to eql("stub_write")
-
-                expect(transaction).to include_event(
-                  "name" => "query.redis",
-                  "body" => "get ?",
-                  "title" => "stub_id"
-                )
-              end
-
-              it "instrument a redis script call" do
-                client = Redis::Client.new
-                script = "return redis.call('set',KEYS[1],ARGV[1])"
-                keys = ["foo"]
-                argv = ["bar"]
-                expect(client.write([:eval, script, keys.size, keys, argv])).to eql("stub_write")
-
-                expect(transaction).to include_event(
-                  "name" => "query.redis",
-                  "body" => "#{script} ? ?",
-                  "title" => "stub_id"
-                )
-              end
-            end
-          end
-        end
-
-        context "with instrumentation disabled" do
-          let(:options) { { :instrument_redis => false } }
-
-          describe "#dependencies_present?" do
-            subject { described_class.new.dependencies_present? }
-
-            it { is_expected.to be_falsy }
-          end
-        end
-      end
-    end
-  else
-    context "without redis" do
-      describe "#dependencies_present?" do
-        subject { described_class.new.dependencies_present? }
-
-        it { is_expected.to be_falsy }
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-describe Appsignal::Hooks::ResqueHook do
-  describe "#dependency_present?" do
-    subject { described_class.new.dependencies_present? }
-
-    context "when Resque is loaded" do
-      before { stub_const "Resque", 1 }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "when Resque is not loaded" do
-      before { hide_const "Resque" }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-
-  if DependencyHelper.resque_present?
-    describe "#install" do
-      before { start_agent }
-
-      it "adds the ResqueIntegration module to Resque::Job" do
-        expect(Resque::Job.included_modules).to include(Appsignal::Integrations::ResqueIntegration)
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-describe Appsignal::Hooks::SequelHook do
-  if DependencyHelper.sequel_present?
-    let(:db) do
-      if DependencyHelper.running_jruby?
-        Sequel.connect("jdbc:sqlite::memory:")
-      else
-        Sequel.sqlite
-      end
-    end
-
-    before { start_agent }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "with a transaction" do
-      let(:transaction) { http_request_transaction }
-      before do
-        set_current_transaction(transaction)
-        db.logger = Logger.new($stdout) # To test #log_duration call
-      end
-
-      it "should instrument queries" do
-        expect(transaction).to receive(:start_event).at_least(:once)
-        expect(transaction).to receive(:finish_event)
-          .at_least(:once)
-          .with("sql.sequel", nil, kind_of(String), 1)
-
-        expect(db).to receive(:log_duration).at_least(:once)
-
-        db["SELECT 1"].all.to_a
-      end
-    end
-  else
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-describe Appsignal::Hooks::ShoryukenHook do
-  context "with shoryuken" do
-    before(:context) do
-      module Shoryuken
-        def self.configure_server
-        end
-      end
-      Appsignal::Hooks::ShoryukenHook.new.install
-    end
-
-    after(:context) do
-      Object.send(:remove_const, :Shoryuken)
-    end
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_truthy }
-    end
-  end
-
-  context "without shoryuken" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-end