appsignal 3.4.13 → 3.6.1

data/spec/lib/appsignal/config_spec.rb

@@ -152,6 +152,7 @@ describe Appsignal::Config do
     it "merges with the default config" do
       expect(config.config_hash).to eq(
         :active                         => true,
+        :activejob_report_errors        => "all",
         :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :debug                          => false,
         :dns_servers                    => [],
@@ -265,7 +266,7 @@ describe Appsignal::Config do
 
     context "with an overriden config file" do
       let(:config) do
-        project_fixture_config("production", {}, Appsignal.logger,
+        project_fixture_config("production", {}, Appsignal.internal_logger,
           File.join(project_fixture_path, "config", "appsignal.yml"))
       end
 
@@ -276,7 +277,7 @@ describe Appsignal::Config do
 
       context "with an invalid overriden config file" do
         let(:config) do
-          project_fixture_config("production", {}, Appsignal.logger,
+          project_fixture_config("production", {}, Appsignal.internal_logger,
             File.join(project_fixture_path, "config", "missing.yml"))
         end
 

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
@@ -222,6 +222,31 @@ if DependencyHelper.active_job_present?
         expect(events).to eq(expected_perform_events)
       end
 
+      context "with activejob_report_errors set to none" do
+        it "does not report the error" do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:activejob_report_errors] = "none"
+
+          # Other calls we're testing in another test
+          allow(Appsignal).to receive(:increment_counter)
+          tags = { :queue => queue }
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_job_count", 1, tags.merge(:status => :failed))
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+
+          expect do
+            perform_job(ActiveJobErrorTestJob)
+          end.to raise_error(RuntimeError, "uh oh")
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "error" => nil
+          )
+        end
+      end
+
       if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
         context "with priority" do
           before do

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/probes/sidekiq_spec.rb

@@ -73,6 +73,20 @@ describe Appsignal::Probes::SidekiqProbe do
       module Sidekiq7Mock
         VERSION = "7.0.0".freeze
 
+        def self.redis_info_data=(info)
+          @redis_info_data = info
+        end
+
+        def self.redis_info_data
+          return @redis_info_data if defined?(@redis_info_data)
+
+          {
+            "connected_clients" => 2,
+            "used_memory" => 1024,
+            "used_memory_rss" => 512
+          }
+        end
+
         def self.redis
           yield Client.new
         end
@@ -83,11 +97,7 @@ describe Appsignal::Probes::SidekiqProbe do
           end
 
           def info
-            {
-              "connected_clients" => 2,
-              "used_memory" => 1024,
-              "used_memory_rss" => 512
-            }
+            Sidekiq7Mock.redis_info_data
           end
         end
 
@@ -227,6 +237,19 @@ describe Appsignal::Probes::SidekiqProbe do
         probe.call
         probe.call
       end
+
+      context "when redis info doesn't contain requested keys" do
+        before { Sidekiq7Mock.redis_info_data = {} }
+
+        it "doesn't create metrics for nil values" do
+          expect_gauge("connection_count").never
+          expect_gauge("memory_usage").never
+          expect_gauge("memory_usage_rss").never
+          # Call probe twice so we can calculate the delta for some gauge values
+          probe.call
+          probe.call
+        end
+      end
     end
 
     context "with Sidekiq 6" do
@@ -301,7 +324,7 @@ describe Appsignal::Probes::SidekiqProbe do
       end
     end
 
-    def expect_gauge(key, value, tags = {})
+    def expect_gauge(key, value = anything, tags = {})
       expect(Appsignal).to receive(:set_gauge)
         .with("sidekiq_#{key}", value, expected_default_tags.merge(tags))
         .and_call_original