appsignal 3.1.5-java → 3.2.0-java

data/lib/appsignal/probes/sidekiq.rb

@@ -3,17 +3,59 @@ module Appsignal
     class SidekiqProbe
       include Helpers
 
+      class Sidekiq7Adapter
+        def self.redis_info
+          redis_info = nil
+          ::Sidekiq.redis { |c| redis_info = c.info }
+          redis_info
+        end
+
+        def self.hostname
+          host = nil
+          ::Sidekiq.redis do |c|
+            host = c.config.host
+          end
+          host
+        end
+      end
+
+      class Sidekiq6Adapter
+        def self.redis_info
+          return unless ::Sidekiq.respond_to?(:redis_info)
+
+          ::Sidekiq.redis_info
+        end
+
+        def self.hostname
+          host = nil
+          ::Sidekiq.redis do |c|
+            host = c.connection[:host] if c.respond_to? :connection
+          end
+          host
+        end
+      end
+
       # @api private
       attr_reader :config
 
+      def self.sidekiq7_and_greater?
+        Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("7.0.0")
+      end
+
       # @api private
       def self.dependencies_present?
+        return true if sidekiq7_and_greater?
+        return unless defined?(::Redis::VERSION) # Sidekiq <= 6
+
         Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
       end
 
       def initialize(config = {})
         @config = config
         @cache = {}
+        is_sidekiq7 = self.class.sidekiq7_and_greater?
+        @adapter = is_sidekiq7 ? Sidekiq7Adapter : Sidekiq6Adapter
+
         config_string = " with config: #{config}" unless config.empty?
         Appsignal.logger.debug("Initializing Sidekiq probe#{config_string}")
         require "sidekiq/api"
@@ -28,11 +70,11 @@ module Appsignal
 
       private
 
-      attr_reader :cache
+      attr_reader :adapter, :cache
 
       def track_redis_info
-        return unless ::Sidekiq.respond_to?(:redis_info)
-        redis_info = ::Sidekiq.redis_info
+        redis_info = adapter.redis_info
+        return unless redis_info
 
         gauge "connection_count", redis_info.fetch("connected_clients")
         gauge "memory_usage", redis_info.fetch("used_memory")
@@ -81,8 +123,7 @@ module Appsignal
           return @hostname
         end
 
-        host = nil
-        ::Sidekiq.redis { |c| host = c.connection[:host] }
+        host = adapter.hostname
         Appsignal.logger.debug "Sidekiq probe: Using Redis server hostname " \
           "#{host.inspect} as hostname"
         @hostname = host

data/lib/appsignal/utils/integration_logger.rb

@@ -0,0 +1,19 @@
+module Appsignal
+  module Utils
+    # Subclass of logger with method to only log a warning once
+    # prevents the local log from filling up with repeated messages.
+    class IntegrationLogger < ::Logger
+      def seen_keys
+        @seen_keys ||= Set.new
+      end
+
+      def warn_once_then_debug(key, message)
+        if !seen_keys.add?(key).nil?
+          warn message
+        else
+          debug message
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/utils.rb

@@ -3,5 +3,6 @@
 require "appsignal/utils/deprecation_message"
 require "appsignal/utils/data"
 require "appsignal/utils/hash_sanitizer"
+require "appsignal/utils/integration_logger"
 require "appsignal/utils/json"
 require "appsignal/utils/query_params_sanitizer"

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.1.5".freeze
+  VERSION = "3.2.0".freeze
 end

data/lib/appsignal.rb

@@ -175,8 +175,8 @@ module Appsignal
     end
 
     def logger
-      @logger ||= Appsignal::Logger.new(in_memory_log).tap do |l|
-        l.level = Logger::INFO
+      @logger ||= Appsignal::Utils::IntegrationLogger.new(in_memory_log).tap do |l|
+        l.level = ::Logger::INFO
         l.formatter = log_formatter("appsignal")
       end
     end
@@ -254,12 +254,12 @@ module Appsignal
     private
 
     def start_stdout_logger
-      @logger = Appsignal::Logger.new($stdout)
+      @logger = Appsignal::Utils::IntegrationLogger.new($stdout)
       logger.formatter = log_formatter("appsignal")
     end
 
     def start_file_logger(path)
-      @logger = Appsignal::Logger.new(path)
+      @logger = Appsignal::Utils::IntegrationLogger.new(path)
       logger.formatter = log_formatter
     rescue SystemCallError => error
       start_stdout_logger

data/spec/lib/appsignal/config_spec.rb

@@ -166,10 +166,12 @@ describe Appsignal::Config do
         :ignore_actions                 => [],
         :ignore_errors                  => [],
         :ignore_namespaces              => [],
+        :instrument_http_rb             => true,
         :instrument_net_http            => true,
         :instrument_redis               => true,
         :instrument_sequel              => true,
         :log                            => "file",
+        :logging_endpoint               => "https://appsignal-endpoint.net",
         :name                           => "TestApp",
         :push_api_key                   => "abc",
         :request_headers                => [],
@@ -536,6 +538,18 @@ describe Appsignal::Config do
         end
       end
     end
+
+    describe ":logging_endpoint" do
+      subject { config[:logging_endpoint] }
+
+      context "with a non-standard port" do
+        let(:config) { project_fixture_config("production", :logging_endpoint => "http://localhost:4567") }
+
+        it "keeps the port" do
+          expect(subject).to eq "http://localhost:4567"
+        end
+      end
+    end
   end
 
   describe "#[]" do
@@ -577,6 +591,7 @@ describe Appsignal::Config do
   describe "#write_to_environment" do
     let(:config) { project_fixture_config(:production) }
     before do
+      config[:logging_endpoint] = "http://localhost:123"
       config[:http_proxy] = "http://localhost"
       config[:ignore_actions] = %w[action1 action2]
       config[:ignore_errors] = %w[ExampleStandardError AnotherError]
@@ -600,6 +615,7 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_DEBUG_LOGGING"]).to                eq "false"
       expect(ENV["_APPSIGNAL_LOG"]).to                          eq "stdout"
       expect(ENV["_APPSIGNAL_LOG_FILE_PATH"]).to                end_with("/tmp/appsignal.log")
+      expect(ENV["_APPSIGNAL_LOGGING_ENDPOINT"]).to             eq "http://localhost:123"
       expect(ENV["_APPSIGNAL_PUSH_API_ENDPOINT"]).to            eq "https://push.appsignal.com"
       expect(ENV["_APPSIGNAL_PUSH_API_KEY"]).to                 eq "abc"
       expect(ENV["_APPSIGNAL_APP_NAME"]).to                     eq "TestApp"

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+describe Appsignal::Hooks::HttpHook do
+  before :context do
+    start_agent
+  end
+
+  if DependencyHelper.http_present?
+    context "with instrument_http_rb set to true" do
+      describe "#dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it { is_expected.to be_truthy }
+      end
+
+      it "installs the HTTP plugin" do
+        expect(HTTP::Client.included_modules)
+          .to include(Appsignal::Integrations::HttpIntegration)
+      end
+    end
+
+    context "with instrument_http_rb set to false" do
+      before { Appsignal.config.config_hash[:instrument_http_rb] = false }
+      after { Appsignal.config.config_hash[:instrument_http_rb] = true }
+
+      describe "#dependencies_present?" do
+        subject { described_class.new.dependencies_present? }
+
+        it { is_expected.to be_falsy }
+      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/integrations/http_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+if DependencyHelper.http_present?
+  require "appsignal/integrations/http"
+
+  describe Appsignal::Integrations::HttpIntegration do
+    let(:transaction) { http_request_transaction }
+
+    around do |example|
+      keep_transactions { example.run }
+    end
+
+    before :context do
+      start_agent
+    end
+
+    before do
+      set_current_transaction(transaction)
+    end
+
+    it "instruments a HTTP request" do
+      stub_request(:get, "http://www.google.com")
+
+      HTTP.get("http://www.google.com")
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include("namespace" => Appsignal::Transaction::HTTP_REQUEST)
+      expect(transaction_hash["events"].first).to include(
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "name" => "request.http_rb",
+        "title" => "GET http://www.google.com"
+      )
+    end
+
+    it "instruments a HTTPS request" do
+      stub_request(:get, "https://www.google.com")
+
+      HTTP.get("https://www.google.com")
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include("namespace" => Appsignal::Transaction::HTTP_REQUEST)
+      expect(transaction_hash["events"].first).to include(
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "name" => "request.http_rb",
+        "title" => "GET https://www.google.com"
+      )
+    end
+
+    context "with request parameters" do
+      it "does not include the query parameters in the title" do
+        stub_request(:get, "https://www.google.com?q=Appsignal")
+
+        HTTP.get("https://www.google.com", :params => { :q => "Appsignal" })
+
+        expect(transaction.to_h["events"].first).to include(
+          "body" => "",
+          "title" => "GET https://www.google.com"
+        )
+      end
+
+      it "does not include the request body in the title" do
+        stub_request(:post, "https://www.google.com")
+          .with(:body => { :q => "Appsignal" }.to_json)
+
+        HTTP.post("https://www.google.com", :json => { :q => "Appsignal" })
+
+        expect(transaction.to_h["events"].first).to include(
+          "body" => "",
+          "title" => "POST https://www.google.com"
+        )
+      end
+    end
+
+    context "with an HTTP exception" do
+      let(:error) { ExampleException.new("oh no!") }
+
+      it "reports the exception and re-raises it" do
+        stub_request(:get, "https://www.google.com").and_raise(error)
+
+        expect do
+          HTTP.get("https://www.google.com")
+        end.to raise_error(ExampleException)
+
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include("namespace" => Appsignal::Transaction::HTTP_REQUEST)
+        expect(transaction_hash["events"].first).to include(
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "name" => "request.http_rb",
+          "title" => "GET https://www.google.com"
+        )
+
+        expect(transaction_hash["error"]).to include(
+          "backtrace" => kind_of(String),
+          "name" => error.class.name,
+          "message" => error.message
+        )
+      end
+    end
+  end
+end

data/spec/lib/appsignal/logger_spec.rb

@@ -1,25 +1,94 @@
 describe Appsignal::Logger do
-  let(:log) { std_stream }
-  let(:logger) do
-    Appsignal::Logger.new(log).tap do |l|
-      l.formatter = logger_formatter
-    end
+  let(:level) { ::Logger::DEBUG }
+  let(:logger) { Appsignal::Logger.new("group", level) }
+
+  it "should not create a logger with a nil group" do
+    expect do
+      Appsignal::Logger.new(nil, level)
+    end.to raise_error(TypeError)
   end
 
-  describe "#seen_keys" do
-    it "returns a Set" do
-      expect(logger.seen_keys).to be_a(Set)
+  describe "#add" do
+    it "should log with a level and message" do
+      expect(Appsignal::Extension).to receive(:log)
+        .with("group", 3, "Log message", instance_of(Appsignal::Extension::Data))
+      logger.add(::Logger::INFO, "Log message")
+    end
+
+    it "should log with a block" do
+      expect(Appsignal::Extension).to receive(:log)
+        .with("group", 3, "Log message", instance_of(Appsignal::Extension::Data))
+      logger.add(::Logger::INFO) do
+        "Log message"
+      end
+    end
+
+    it "should log with a level, message and group" do
+      expect(Appsignal::Extension).to receive(:log)
+        .with("other_group", 3, "Log message", instance_of(Appsignal::Extension::Data))
+      logger.add(::Logger::INFO, "Log message", "other_group")
+    end
+
+    it "should return with a nil message" do
+      expect(Appsignal::Extension).not_to receive(:log)
+      logger.add(::Logger::INFO, nil)
+    end
+
+    context "with debug log level" do
+      let(:level) { ::Logger::INFO }
+
+      it "should skip logging if the level is too low" do
+        expect(Appsignal::Extension).not_to receive(:log)
+        logger.add(::Logger::DEBUG, "Log message")
+      end
     end
   end
 
-  describe "#warn_once_then_debug" do
-    it "only warns once, then uses debug" do
-      message = "This is a log line"
-      3.times { logger.warn_once_then_debug(:key, message) }
+  [
+    ["debug", 2, ::Logger::INFO],
+    ["info", 3, ::Logger::WARN],
+    ["warn", 5, ::Logger::ERROR],
+    ["error", 6, ::Logger::FATAL],
+    ["fatal", 7, nil]
+  ].each do |method|
+    describe "##{method[0]}" do
+      it "should log with a message" do
+        expect(Appsignal::Utils::Data).to receive(:generate)
+          .with({})
+          .and_call_original
+        expect(Appsignal::Extension).to receive(:log)
+          .with("group", method[1], "Log message", instance_of(Appsignal::Extension::Data))
+
+        logger.send(method[0], "Log message")
+      end
+
+      it "should log with a block" do
+        expect(Appsignal::Utils::Data).to receive(:generate)
+          .with({})
+          .and_call_original
+        expect(Appsignal::Extension).to receive(:log)
+          .with("group", method[1], "Log message", instance_of(Appsignal::Extension::Data))
+
+        logger.send(method[0]) do
+          "Log message"
+        end
+      end
+
+      it "should return with a nil message" do
+        expect(Appsignal::Extension).not_to receive(:log)
+        logger.send(method[0])
+      end
+
+      if method[2]
+        context "with a lower log level" do
+          let(:level) { method[2] }
 
-      logs = log_contents(log)
-      expect(logs.scan(/#{Regexp.escape(log_line(:WARN, message))}/).count).to eql(1)
-      expect(logs.scan(/#{Regexp.escape(log_line(:DEBUG, message))}/).count).to eql(2)
+          it "should skip logging if the level is too low" do
+            expect(Appsignal::Extension).not_to receive(:log)
+            logger.send(method[0], "Log message")
+          end
+        end
+      end
     end
   end
 end