appsignal 3.5.4 → 3.5.6

data/lib/appsignal.rb

@@ -46,7 +46,11 @@ module Appsignal
     # @see extension_loaded?
     attr_accessor :extension_loaded
     # @!attribute [rw] logger
-    #   Accessor for the AppSignal logger.
+    #   Accessor for the internal AppSignal logger.
+    #
+    #   Not to be confused with our logging feature.
+    #   This is part of our private internal API. Do not call this method
+    #   directly.
     #
     #   If no logger has been set, it will return a "in memory logger", using
     #   `in_memory_log`. Once AppSignal is started (using {.start}) the
@@ -57,7 +61,7 @@ module Appsignal
     #   @api private
     #   @return [Logger]
     #   @see start_logger
-    attr_writer :logger
+    attr_writer :internal_logger
 
     # @api private
     def testing?
@@ -91,11 +95,11 @@ module Appsignal
     # @since 0.7.0
     def start
       unless extension_loaded?
-        logger.info("Not starting appsignal, extension is not loaded")
+        internal_logger.info("Not starting appsignal, extension is not loaded")
         return
       end
 
-      logger.debug("Starting appsignal")
+      internal_logger.debug("Starting appsignal")
 
       @config ||= Config.new(
         Dir.pwd,
@@ -103,9 +107,9 @@ module Appsignal
       )
 
       if config.valid?
-        logger.level = config.log_level
+        internal_logger.level = config.log_level
         if config.active?
-          logger.info "Starting AppSignal #{Appsignal::VERSION} " \
+          internal_logger.info "Starting AppSignal #{Appsignal::VERSION} " \
             "(#{$PROGRAM_NAME}, Ruby #{RUBY_VERSION}, #{RUBY_PLATFORM})"
           config.write_to_environment
           Appsignal::Extension.start
@@ -120,10 +124,10 @@ module Appsignal
 
           collect_environment_metadata
         else
-          logger.info("Not starting, not active for #{config.env}")
+          internal_logger.info("Not starting, not active for #{config.env}")
         end
       else
-        logger.error("Not starting, no valid config for this environment")
+        internal_logger.error("Not starting, no valid config for this environment")
       end
     end
 
@@ -143,9 +147,9 @@ module Appsignal
     # @since 1.0.0
     def stop(called_by = nil)
       if called_by
-        logger.debug("Stopping appsignal (#{called_by})")
+        internal_logger.debug("Stopping appsignal (#{called_by})")
       else
-        logger.debug("Stopping appsignal")
+        internal_logger.debug("Stopping appsignal")
       end
       Appsignal::Extension.stop
     end
@@ -154,7 +158,7 @@ module Appsignal
       return unless active?
 
       Appsignal.start_logger
-      logger.debug("Forked process, resubscribing and restarting extension")
+      internal_logger.debug("Forked process, resubscribing and restarting extension")
       Appsignal::Extension.start
     end
 
@@ -162,7 +166,8 @@ module Appsignal
       Appsignal::Extension.get_server_state(key)
     end
 
-    # In memory logger used before any logger is started with {.start_logger}.
+    # In memory internal logger used before any internal logger is started with
+    # {.start_logger}.
     #
     # The contents of this logger are flushed to the logger in {.start_logger}.
     #
@@ -176,11 +181,12 @@ module Appsignal
       end
     end
 
-    def logger
-      @logger ||= Appsignal::Utils::IntegrationLogger.new(in_memory_log).tap do |l|
-        l.level = ::Logger::INFO
-        l.formatter = log_formatter("appsignal")
-      end
+    def internal_logger
+      @internal_logger ||=
+        Appsignal::Utils::IntegrationLogger.new(in_memory_log).tap do |l|
+          l.level = ::Logger::INFO
+          l.formatter = log_formatter("appsignal")
+        end
     end
 
     # @api private
@@ -192,7 +198,7 @@ module Appsignal
       end
     end
 
-    # Start the AppSignal logger.
+    # Start the AppSignal internal logger.
     #
     # Sets the log level and sets the logger. Uses a file-based logger or the
     # STDOUT-based logger. See the `:log` configuration option.
@@ -201,18 +207,18 @@ module Appsignal
     # @since 0.7.0
     def start_logger
       if config && config[:log] == "file" && config.log_file_path
-        start_file_logger(config.log_file_path)
+        start_internal_file_logger(config.log_file_path)
       else
-        start_stdout_logger
+        start_internal_stdout_logger
       end
 
-      logger.level =
+      internal_logger.level =
         if config
           config.log_level
         else
           Appsignal::Config::DEFAULT_LOG_LEVEL
         end
-      logger << @in_memory_log.string if @in_memory_log
+      internal_logger << @in_memory_log.string if @in_memory_log
     end
 
     # Returns if the C-extension was loaded properly.
@@ -255,18 +261,18 @@ module Appsignal
 
     private
 
-    def start_stdout_logger
-      @logger = Appsignal::Utils::IntegrationLogger.new($stdout)
-      logger.formatter = log_formatter("appsignal")
+    def start_internal_stdout_logger
+      @internal_logger = Appsignal::Utils::IntegrationLogger.new($stdout)
+      internal_logger.formatter = log_formatter("appsignal")
     end
 
-    def start_file_logger(path)
-      @logger = Appsignal::Utils::IntegrationLogger.new(path)
-      logger.formatter = log_formatter
+    def start_internal_file_logger(path)
+      @internal_logger = Appsignal::Utils::IntegrationLogger.new(path)
+      internal_logger.formatter = log_formatter
     rescue SystemCallError => error
-      start_stdout_logger
-      logger.warn "Unable to start logger with log path '#{path}'."
-      logger.warn error
+      start_internal_stdout_logger
+      internal_logger.warn "Unable to start internal logger with log path '#{path}'."
+      internal_logger.warn error
     end
 
     def collect_environment_metadata

data/spec/lib/appsignal/config_spec.rb

@@ -265,7 +265,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 +276,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

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