appsignal 3.5.4-java → 3.5.5-java

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

@@ -76,7 +76,7 @@ if DependencyHelper.active_job_present?
       ActiveJob::Base.queue_adapter = :inline
 
       start_agent
-      Appsignal.logger = test_logger(log)
+      Appsignal.internal_logger = test_logger(log)
       class ActiveJobTestJob < ActiveJob::Base
         def perform(*_args)
         end

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

@@ -0,0 +1,222 @@
+describe Appsignal::Hooks::RedisClientHook do
+  before do
+    Appsignal.config = project_fixture_config
+  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? }
+
+          it { is_expected.to be_truthy }
+        end
+
+        context "with rest-client gem" do
+          describe "integration" do
+            before do
+              Appsignal.config.config_hash[:instrument_redis] = true
+            end
+
+            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) do
+                Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+              end
+              let!(:client_config) { RedisClient::Config.new(:id => "stub_id") }
+              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")
+
+                transaction_hash = transaction.to_h
+                expect(transaction_hash["events"]).to include(
+                  hash_including(
+                    "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")
+
+                transaction_hash = transaction.to_h
+                expect(transaction_hash["events"]).to include(
+                  hash_including(
+                    "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
+              before do
+                Appsignal.config.config_hash[:instrument_redis] = true
+              end
+
+              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) do
+                  Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST,
+                    "test")
+                end
+                let!(:client_config) { RedisClient::Config.new(:id => "stub_id") }
+                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")
+
+                  transaction_hash = transaction.to_h
+                  expect(transaction_hash["events"]).to include(
+                    hash_including(
+                      "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")
+
+                  transaction_hash = transaction.to_h
+                  expect(transaction_hash["events"]).to include(
+                    hash_including(
+                      "name" => "query.redis",
+                      "body" => "#{script} ? ?",
+                      "title" => "stub_id"
+                    )
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context "with instrumentation disabled" do
+        before do
+          Appsignal.config.config_hash[:instrument_redis] = false
+        end
+
+        describe "#dependencies_present?" do
+          subject { described_class.new.dependencies_present? }
+
+          it { is_expected.to be_falsy }
+        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/redis_spec.rb

@@ -5,100 +5,122 @@ describe Appsignal::Hooks::RedisHook do
 
   if DependencyHelper.redis_present?
     context "with redis" do
-      context "with instrumentation enabled" do
-        describe "#dependencies_present?" do
-          subject { described_class.new.dependencies_present? }
+      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_truthy }
+              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? }
 
-        describe "integration" do
-          before do
-            Appsignal.config.config_hash[:instrument_redis] = true
+            it { is_expected.to be_truthy }
           end
 
-          context "install" do
+          describe "integration" do
             before do
-              Appsignal::Hooks.load_hooks
+              Appsignal.config.config_hash[:instrument_redis] = true
             end
 
-            it "does something" 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 "install" do
+              before do
+                Appsignal::Hooks.load_hooks
+              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) do
-              Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+              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
-            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")
-
-              transaction_hash = transaction.to_h
-              expect(transaction_hash["events"]).to include(
-                hash_including(
-                  "name" => "query.redis",
-                  "body" => "get ?",
-                  "title" => "stub_id"
-                )
-              )
+
+            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
 
-            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")
-
-              transaction_hash = transaction.to_h
-              expect(transaction_hash["events"]).to include(
-                hash_including(
-                  "name" => "query.redis",
-                  "body" => "#{script} ? ?",
-                  "title" => "stub_id"
-                )
-              )
+            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) do
+                Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+              end
+              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")
+
+                transaction_hash = transaction.to_h
+                expect(transaction_hash["events"]).to include(
+                                                        hash_including(
+                                                          "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")
+
+                transaction_hash = transaction.to_h
+                expect(transaction_hash["events"]).to include(
+                                                        hash_including(
+                                                          "name" => "query.redis",
+                                                          "body" => "#{script} ? ?",
+                                                          "title" => "stub_id"
+                                                        )
+                                                      )
+              end
             end
           end
         end
-      end
 
-      context "with instrumentation disabled" do
-        before do
-          Appsignal.config.config_hash[:instrument_redis] = false
-        end
+        context "with instrumentation disabled" do
+          before do
+            Appsignal.config.config_hash[:instrument_redis] = false
+          end
 
-        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_falsy }
+            it { is_expected.to be_falsy }
+          end
         end
       end
     end

data/spec/lib/appsignal/hooks_spec.rb

@@ -67,12 +67,12 @@ describe Appsignal::Hooks do
     expect(Appsignal::Hooks.hooks[:mock_error_hook]).to be_instance_of(MockErrorHook)
     expect(Appsignal::Hooks.hooks[:mock_error_hook].installed?).to be_falsy
 
-    expect(Appsignal.logger).to receive(:error)
+    expect(Appsignal.internal_logger).to receive(:error)
       .with("Error while installing mock_error_hook hook: error").once
-    expect(Appsignal.logger).to receive(:debug).ordered do |message|
+    expect(Appsignal.internal_logger).to receive(:debug).ordered do |message|
       expect(message).to eq("Installing mock_error_hook hook")
     end
-    expect(Appsignal.logger).to receive(:debug).ordered do |message|
+    expect(Appsignal.internal_logger).to receive(:debug).ordered do |message|
       # Start of the error backtrace as debug log
       expect(message).to start_with(File.expand_path("../../..", __dir__))
     end
@@ -89,7 +89,7 @@ describe Appsignal::Hooks do
     let(:log_stream) { std_stream }
     let(:log) { log_contents(log_stream) }
     before do
-      Appsignal.logger = test_logger(log_stream)
+      Appsignal.internal_logger = test_logger(log_stream)
     end
 
     def call_constant(&block)

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

@@ -18,9 +18,9 @@ if DependencyHelper.rails_present?
     describe "#initialize_appsignal" do
       let(:app) { MyApp::Application.new }
 
-      describe ".logger" do
+      describe ".internal_logger" do
         before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-        subject { Appsignal.logger }
+        subject { Appsignal.internal_logger }
 
         it { is_expected.to be_a Logger }
       end

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

@@ -4,7 +4,7 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
   let(:log) { StringIO.new }
   before do
     start_agent
-    Appsignal.logger = test_logger(log)
+    Appsignal.internal_logger = test_logger(log)
   end
   around { |example| keep_transactions { example.run } }
 
@@ -86,7 +86,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
   let(:log) { StringIO.new }
   before do
     start_agent
-    Appsignal.logger = test_logger(log)
+    Appsignal.internal_logger = test_logger(log)
   end
   around { |example| keep_transactions { example.run } }
   after :with_yaml_parse_error => false do
@@ -423,7 +423,7 @@ if DependencyHelper.active_job_present?
     end
     around do |example|
       start_agent
-      Appsignal.logger = test_logger(log)
+      Appsignal.internal_logger = test_logger(log)
       ActiveJob::Base.queue_adapter = :sidekiq
 
       class ActiveJobSidekiqTestJob < ActiveJob::Base

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

@@ -16,8 +16,8 @@ if DependencyHelper.sinatra_present?
     before { allow(Appsignal).to receive(:active?).and_return(true) }
     after { uninstall_sinatra_integration }
 
-    context "Appsignal.logger" do
-      subject { Appsignal.logger }
+    context "Appsignal.internal_logger" do
+      subject { Appsignal.internal_logger }
 
       it "sets a logger" do
         install_sinatra_integration

data/spec/lib/appsignal/minutely_spec.rb

@@ -42,7 +42,7 @@ describe Appsignal::Minutely do
     let(:log_stream) { StringIO.new }
     let(:log) { log_contents(log_stream) }
     before do
-      Appsignal.logger = test_logger(log_stream)
+      Appsignal.internal_logger = test_logger(log_stream)
       # Speed up test time
       allow(Appsignal::Minutely).to receive(:initial_wait_time).and_return(0.001)
       allow(Appsignal::Minutely).to receive(:wait_time).and_return(0.001)
@@ -287,7 +287,7 @@ describe Appsignal::Minutely do
     describe "#register" do
       let(:log_stream) { std_stream }
       let(:log) { log_contents(log_stream) }
-      before { Appsignal.logger = test_logger(log_stream) }
+      before { Appsignal.internal_logger = test_logger(log_stream) }
 
       it "adds the by key probe" do
         probe = lambda {}

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

@@ -6,7 +6,7 @@ if DependencyHelper.rails_present?
     let(:log) { StringIO.new }
     before do
       start_agent
-      Appsignal.logger = test_logger(log)
+      Appsignal.internal_logger = test_logger(log)
     end
 
     let(:params) do

data/spec/lib/appsignal/transaction_spec.rb

@@ -580,7 +580,7 @@ describe Appsignal::Transaction do
       it "does not raise an error when the queue start is too big" do
         expect(transaction.ext).to receive(:set_queue_start).and_raise(RangeError)
 
-        expect(Appsignal.logger).to receive(:warn).with("Queue start value 10 is too big")
+        expect(Appsignal.internal_logger).to receive(:warn).with("Queue start value 10 is too big")
 
         expect do
           transaction.set_queue_start(10)
@@ -766,7 +766,7 @@ describe Appsignal::Transaction do
         let(:error) { Object.new }
 
         it "does not add the error" do
-          expect(Appsignal.logger).to receive(:error).with(
+          expect(Appsignal.internal_logger).to receive(:error).with(
             "Appsignal::Transaction#set_error: Cannot set error. " \
               "The given value is not an exception: #{error.inspect}"
           )
@@ -830,7 +830,7 @@ describe Appsignal::Transaction do
             )
           )
 
-          expect(Appsignal.logger).to_not receive(:debug)
+          expect(Appsignal.internal_logger).to_not receive(:debug)
 
           transaction.set_error(error)
         end
@@ -871,7 +871,7 @@ describe Appsignal::Transaction do
             Appsignal::Utils::Data.generate(expected_error_causes)
           )
 
-          expect(Appsignal.logger).to receive(:debug).with(
+          expect(Appsignal.internal_logger).to receive(:debug).with(
             "Appsignal::Transaction#set_error: Error has more " \
               "than 10 error causes. Only the first 10 " \
               "will be reported."