appsignal 2.10.8-java → 2.11.0.beta.1-java

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

@@ -0,0 +1,204 @@
+require "appsignal/probes/sidekiq"
+
+describe Appsignal::Probes::SidekiqProbe do
+  describe "#call" do
+    let(:probe) { described_class.new }
+    let(:redis_hostname) { "localhost" }
+    let(:expected_default_tags) { { :hostname => "localhost" } }
+    before do
+      Appsignal.config = project_fixture_config
+      module SidekiqMock
+        def self.redis_info
+          {
+            "connected_clients" => 2,
+            "used_memory" => 1024,
+            "used_memory_rss" => 512
+          }
+        end
+
+        def self.redis
+          yield Client.new
+        end
+
+        class Client
+          def connection
+            { :host => "localhost" }
+          end
+        end
+
+        class Stats
+          class << self
+            attr_reader :calls
+
+            def count_call
+              @calls ||= -1
+              @calls += 1
+            end
+          end
+
+          def workers_size
+            # First method called, so count it towards a call
+            self.class.count_call
+            24
+          end
+
+          def processes_size
+            25
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def processed
+            [10, 15][self.class.calls]
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def failed
+            [10, 13][self.class.calls]
+          end
+
+          def retry_size
+            12
+          end
+
+          # Return two different values for two separate calls.
+          # This allows us to test the delta of the value send as a gauge.
+          def dead_size
+            [10, 12][self.class.calls]
+          end
+
+          def scheduled_size
+            14
+          end
+
+          def enqueued
+            15
+          end
+        end
+
+        class Queue
+          Queue = Struct.new(:name, :size, :latency)
+
+          def self.all
+            [
+              Queue.new("default", 10, 12),
+              Queue.new("critical", 1, 2)
+            ]
+          end
+        end
+      end
+      stub_const("Sidekiq", SidekiqMock)
+    end
+    after { Object.send(:remove_const, :SidekiqMock) }
+
+    describe ".dependencies_present?" do
+      before do
+        stub_const("Redis::VERSION", version)
+      end
+
+      context "when Redis version is < 3.3.5" do
+        let(:version) { "3.3.4" }
+
+        it "does not start probe" do
+          expect(described_class.dependencies_present?).to be_falsy
+        end
+      end
+
+      context "when Redis version is >= 3.3.5" do
+        let(:version) { "3.3.5" }
+
+        it "does not start probe" do
+          expect(described_class.dependencies_present?).to be_truthy
+        end
+      end
+    end
+
+    it "loads Sidekiq::API" do
+      # Hide the Sidekiq constant if it was already loaded. It will be
+      # redefined by loading "sidekiq/api" in the probe.
+      hide_const "Sidekiq::Stats"
+
+      expect(defined?(Sidekiq::Stats)).to be_falsy
+      probe
+      expect(defined?(Sidekiq::Stats)).to be_truthy
+    end
+
+    it "logs config on initialize" do
+      log = capture_logs { probe }
+      expect(log).to contains_log(:debug, "Initializing Sidekiq probe\n")
+    end
+
+    it "logs used hostname on call once" do
+      log = capture_logs { probe.call }
+      expect(log).to contains_log(
+        :debug,
+        %(Sidekiq probe: Using Redis server hostname "localhost" as hostname)
+      )
+      log = capture_logs { probe.call }
+      # Match more logs with incompelete message
+      expect(log).to_not contains_log(:debug, %(Sidekiq probe: ))
+    end
+
+    it "collects custom metrics" do
+      expect_gauge("worker_count", 24).twice
+      expect_gauge("process_count", 25).twice
+      expect_gauge("connection_count", 2).twice
+      expect_gauge("memory_usage", 1024).twice
+      expect_gauge("memory_usage_rss", 512).twice
+      expect_gauge("job_count", 5, :status => :processed) # Gauge delta
+      expect_gauge("job_count", 3, :status => :failed) # Gauge delta
+      expect_gauge("job_count", 12, :status => :retry_queue).twice
+      expect_gauge("job_count", 2, :status => :died) # Gauge delta
+      expect_gauge("job_count", 14, :status => :scheduled).twice
+      expect_gauge("job_count", 15, :status => :enqueued).twice
+      expect_gauge("queue_length", 10, :queue => "default").twice
+      expect_gauge("queue_latency", 12_000, :queue => "default").twice
+      expect_gauge("queue_length", 1, :queue => "critical").twice
+      expect_gauge("queue_latency", 2_000, :queue => "critical").twice
+      # Call probe twice so we can calculate the delta for some gauge values
+      probe.call
+      probe.call
+    end
+
+    context "when `redis_info` is not defined" do
+      before do
+        allow(Sidekiq).to receive(:respond_to?).with(:redis_info).and_return(false)
+      end
+
+      it "does not collect redis metrics" do
+        expect_gauge("connection_count", 2).never
+        expect_gauge("memory_usage", 1024).never
+        expect_gauge("memory_usage_rss", 512).never
+        probe.call
+      end
+    end
+
+    context "when hostname is configured for probe" do
+      let(:redis_hostname) { "my_redis_server" }
+      let(:probe) { described_class.new(:hostname => redis_hostname) }
+
+      it "uses the redis hostname for the hostname tag" do
+        allow(Appsignal).to receive(:set_gauge).and_call_original
+        log = capture_logs { probe }
+        expect(log).to contains_log(
+          :debug,
+          %(Initializing Sidekiq probe with config: {:hostname=>"#{redis_hostname}"})
+        )
+        log = capture_logs { probe.call }
+        expect(log).to contains_log(
+          :debug,
+          "Sidekiq probe: Using hostname config option #{redis_hostname.inspect} as hostname"
+        )
+        expect(Appsignal).to have_received(:set_gauge)
+          .with(anything, anything, :hostname => redis_hostname).at_least(:once)
+      end
+    end
+
+    def expect_gauge(key, value, tags = {})
+      expect(Appsignal).to receive(:set_gauge)
+        .with("sidekiq_#{key}", value, expected_default_tags.merge(tags))
+        .and_call_original
+    end
+  end
+end

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

@@ -4,9 +4,12 @@ describe Appsignal::Rack::JSExceptionCatcher do
   let(:config_options) { { :enable_frontend_error_catching => true } }
   let(:config)         { project_fixture_config("production", config_options) }
   let(:deprecation_message) do
-    "The Appsignal::Rack::JSExceptionCatcher is deprecated. " \
-      "Please use the official AppSignal JavaScript integration instead. " \
-      "https://docs.appsignal.com/front-end/"
+    "The Appsignal::Rack::JSExceptionCatcher is " \
+      "deprecated and will be removed in a future version. Please use " \
+      "the official AppSignal JavaScript integration by disabling " \
+      "`enable_frontend_error_catching` in your configuration and " \
+      "installing AppSignal for JavaScript instead. " \
+      "(https://docs.appsignal.com/front-end/)"
   end
   before { Appsignal.config = config }
 
@@ -32,7 +35,9 @@ describe Appsignal::Rack::JSExceptionCatcher do
 
   describe "#call" do
     let(:catcher) do
-      silence { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+      silence :allowed => ["enable_frontend_error_catching"] do
+        Appsignal::Rack::JSExceptionCatcher.new(app, options)
+      end
     end
     after { catcher.call(env) }
 

data/spec/lib/appsignal/transaction_spec.rb

@@ -473,22 +473,20 @@ describe Appsignal::Transaction do
       end
     end
 
-    describe "set_queue_start" do
-      it "should set the queue start in extension" do
-        expect(transaction.ext).to receive(:set_queue_start).with(
-          10.0
-        ).once
+    describe "#set_queue_start" do
+      it "sets the queue start in extension" do
+        expect(transaction.ext).to receive(:set_queue_start).with(10.0).once
 
         transaction.set_queue_start(10.0)
       end
 
-      it "should not set the queue start in extension when value is nil" do
+      it "does not set the queue start in extension when value is nil" do
         expect(transaction.ext).to_not receive(:set_queue_start)
 
         transaction.set_queue_start(nil)
       end
 
-      it "should not raise an error when the queue start is too big" 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")
@@ -500,23 +498,40 @@ describe Appsignal::Transaction do
     end
 
     describe "#set_http_or_background_queue_start" do
-      context "for a http transaction" do
-        let(:namespace) { Appsignal::Transaction::HTTP_REQUEST }
-        let(:env) { { "HTTP_X_REQUEST_START" => (fixed_time * 1000).to_s } }
+      let(:header_factor) { 1_000 }
+      let(:env_queue_start) { fixed_time + 20 } # in seconds
+
+      context "when a queue time is found in a request header" do
+        let(:header_time) { ((fixed_time + 10) * header_factor).to_i } # in milliseconds
+        let(:env) { { "HTTP_X_REQUEST_START" => "t=#{header_time}" } }
 
-        it "should set the queue start on the transaction" do
-          expect(transaction).to receive(:set_queue_start).with(13_897_836_000)
+        it "sets the http header value in milliseconds on the transaction" do
+          expect(transaction).to receive(:set_queue_start).with(1_389_783_610_000)
 
           transaction.set_http_or_background_queue_start
         end
+
+        context "when a :queue_start key is found in the transaction environment" do
+          let(:env) do
+            {
+              "HTTP_X_REQUEST_START" => "t=#{header_time}",
+              :queue_start => env_queue_start
+            }
+          end
+
+          it "sets the http header value in milliseconds on the transaction" do
+            expect(transaction).to receive(:set_queue_start).with(1_389_783_610_000)
+
+            transaction.set_http_or_background_queue_start
+          end
+        end
       end
 
-      context "for a background transaction" do
-        let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
-        let(:env) { { :queue_start => fixed_time } }
+      context "when a :queue_start key is found in the transaction environment" do
+        let(:env) { { :queue_start => env_queue_start } } # in seconds
 
-        it "should set the queue start on the transaction" do
-          expect(transaction).to receive(:set_queue_start).with(1_389_783_600_000)
+        it "sets the :queue_start value in milliseconds on the transaction" do
+          expect(transaction).to receive(:set_queue_start).with(1_389_783_620_000)
 
           transaction.set_http_or_background_queue_start
         end
@@ -910,7 +925,7 @@ describe Appsignal::Transaction do
       context "when queue start is set" do
         let(:env) { background_env_with_data }
 
-        it { is_expected.to eq 1_389_783_590_000 }
+        it { is_expected.to eq 1_389_783_600_000 }
       end
     end
 
@@ -949,7 +964,7 @@ describe Appsignal::Transaction do
             it { is_expected.to be_nil }
           end
 
-          context "with some cruft" do
+          context "with unparsable content at the end" do
             let(:env) { { "HTTP_X_REQUEST_START" => "t=#{slightly_earlier_time_value}aaaa" } }
 
             it { is_expected.to eq 1_389_783_599_600 }
@@ -969,7 +984,7 @@ describe Appsignal::Transaction do
         end
       end
 
-      context "time in miliseconds" do
+      context "time in milliseconds" do
         let(:factor) { 1_000 }
 
         it_should_behave_like "http queue start"

data/spec/lib/appsignal_spec.rb

@@ -1,4 +1,6 @@
 describe Appsignal do
+  include EnvironmentMetadataHelper
+
   before do
     # Make sure we have a clean state because we want to test
     # initialization here.
@@ -80,18 +82,22 @@ describe Appsignal do
           allow(GC::Profiler).to receive(:enable)
           Appsignal.config.config_hash[:enable_allocation_tracking] = true
           Appsignal.config.config_hash[:enable_gc_instrumentation] = true
+          capture_environment_metadata_report_calls
         end
 
         it "should enable Ruby's GC::Profiler" do
           expect(GC::Profiler).to receive(:enable)
           Appsignal.start
+          expect_environment_metadata("ruby_gc_instrumentation_enabled", "true")
         end
 
         unless Appsignal::System.jruby?
+
           it "installs the allocation event hook" do
             expect(Appsignal::Extension).to receive(:install_allocation_event_hook)
               .and_call_original
             Appsignal.start
+            expect_environment_metadata("ruby_allocation_tracking_enabled", "true")
           end
         end
       end
@@ -100,6 +106,7 @@ describe Appsignal do
         before do
           Appsignal.config.config_hash[:enable_allocation_tracking] = false
           Appsignal.config.config_hash[:enable_gc_instrumentation] = false
+          capture_environment_metadata_report_calls
         end
 
         it "should not enable Ruby's GC::Profiler" do
@@ -110,11 +117,13 @@ describe Appsignal do
         it "should not install the allocation event hook" do
           expect(Appsignal::Minutely).not_to receive(:install_allocation_event_hook)
           Appsignal.start
+          expect_not_environment_metadata("ruby_allocation_tracking_enabled")
         end
 
         it "should not add the gc probe to minutely" do
           expect(Appsignal::Minutely).not_to receive(:register_garbage_collection_probe)
           Appsignal.start
+          expect_not_environment_metadata("ruby_gc_instrumentation_enabled")
         end
       end
 
@@ -139,6 +148,19 @@ describe Appsignal do
           Appsignal.start
         end
       end
+
+      describe "environment metadata" do
+        before { capture_environment_metadata_report_calls }
+
+        it "collects and reports environment metadata" do
+          Appsignal.start
+          expect_environment_metadata("ruby_version", "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}")
+          expect_environment_metadata("ruby_engine", RUBY_ENGINE)
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
+            expect_environment_metadata("ruby_engine_version", RUBY_ENGINE_VERSION)
+          end
+        end
+      end
     end
 
     context "with debug logging" do

data/spec/lib/puma/appsignal_spec.rb

@@ -62,7 +62,7 @@ RSpec.describe "Puma plugin" do
     expect(launcher.events.on_booted).to_not be_nil
 
     launcher.events.on_booted.call
-    expect(Appsignal::Minutely.probes[:puma]).to eql(Appsignal::Hooks::PumaProbe)
+    expect(Appsignal::Minutely.probes[:puma]).to eql(Appsignal::Probes::PumaProbe)
 
     # Minutely probes started and called
     wait_for("enough probe calls") { probe.calls >= 2 }

data/spec/support/helpers/action_mailer_helpers.rb

@@ -0,0 +1,25 @@
+module ActionMailerHelpers
+  def perform_action_mailer(mailer, method, args = nil)
+    if DependencyHelper.rails_version >= Gem::Version.new("5.2.0")
+      case args
+      when Array
+        mailer.send(method, *args).deliver_later
+      when Hash
+        mailer.with(args).send(method).deliver_later
+      when NilClass
+        mailer.send(method).deliver_later
+      else
+        raise "Unknown scenario for arguments: #{args}"
+      end
+    else
+      # Rails 5.1 and lower
+      mailer_object =
+        if args
+          mailer.send(method, *args)
+        else
+          mailer.send(method)
+        end
+      mailer_object.deliver_later
+    end
+  end
+end

data/spec/support/helpers/dependency_helper.rb

@@ -1,6 +1,10 @@
 module DependencyHelper
   module_function
 
+  def ruby_version
+    Gem::Version.new(RUBY_VERSION)
+  end
+
   def running_jruby?
     defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
   end
@@ -9,6 +13,14 @@ module DependencyHelper
     dependency_present? "rails"
   end
 
+  def rails6_present?
+    rails_present? && rails_version >= Gem::Version.new("6.0.0")
+  end
+
+  def rails_version
+    Gem.loaded_specs["rails"].version
+  end
+
   def sequel_present?
     dependency_present? "sequel"
   end