appsignal 4.0.2-java → 4.0.4-java

data/spec/lib/appsignal/config_spec.rb

@@ -1363,30 +1363,5 @@ describe Appsignal::Config do
 
       expect(dsl.cpu_count).to eq(1.0)
     end
-
-    describe "#app_path=" do
-      it "prints a deprecation warning" do
-        err_stream = std_stream
-        capture_std_streams(std_stream, err_stream) do
-          dsl.app_path = "foo"
-        end
-
-        expect(err_stream.read).to include(
-          "appsignal WARNING: The `Appsignal.configure`'s `app_path=` writer is deprecated"
-        )
-      end
-
-      it "logs a deprecation warning" do
-        logs =
-          capture_logs do
-            silence { dsl.app_path = "foo" }
-          end
-
-        expect(logs).to contains_log(
-          :warn,
-          "The `Appsignal.configure`'s `app_path=` writer is deprecated"
-        )
-      end
-    end
   end
 end

data/spec/lib/appsignal/environment_spec.rb

@@ -115,12 +115,33 @@ describe Appsignal::Environment do
   end
 
   describe ".report_supported_gems" do
-    it "reports about all AppSignal supported gems in the bundle" do
+    it "reports about all AppSignal supported gems in the bundle using Bundler all_specs" do
       logs = capture_logs { described_class.report_supported_gems }
 
       expect(logs).to be_empty
 
-      bundle_gem_specs = ::Bundler.rubygems.all_specs
+      unless Bundler.rubygems.respond_to?(:all_specs)
+        skip "Using new Bundler version without `all_specs` method"
+      end
+      bundle_gem_specs = silence { ::Bundler.rubygems.all_specs }
+      rack_spec = bundle_gem_specs.find { |s| s.name == "rack" }
+      rake_spec = bundle_gem_specs.find { |s| s.name == "rake" }
+      expect_environment_metadata("ruby_rack_version", rack_spec.version.to_s)
+      expect_environment_metadata("ruby_rake_version", rake_spec.version.to_s)
+      expect(rack_spec.version.to_s).to_not be_empty
+      expect(rake_spec.version.to_s).to_not be_empty
+    end
+
+    it "reports about all AppSignal supported gems in the bundle using bundler installed_specs" do
+      unless Bundler.rubygems.respond_to?(:installed_specs)
+        skip "Using old Bundler version without `installed_specs` method"
+      end
+
+      logs = capture_logs { described_class.report_supported_gems }
+
+      expect(logs).to be_empty
+
+      bundle_gem_specs = ::Bundler.rubygems.installed_specs
       rack_spec = bundle_gem_specs.find { |s| s.name == "rack" }
       rake_spec = bundle_gem_specs.find { |s| s.name == "rake" }
       expect_environment_metadata("ruby_rack_version", rack_spec.version.to_s)

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

@@ -80,4 +80,15 @@ describe Appsignal::Hooks::AtExit::AtExitCallback do
       end.to_not change { created_transactions.count }.from(1)
     end
   end
+
+  it "doesn't report the error if it is a SignalException exception" do
+    with_error(SignalException, "TERM") do |error|
+      Appsignal.report_error(error)
+      expect(created_transactions.count).to eq(1)
+
+      expect do
+        call_callback
+      end.to_not change { created_transactions.count }.from(1)
+    end
+  end
 end

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

@@ -229,15 +229,36 @@ if DependencyHelper.rails_present?
           expect(last_transaction).to have_error("ExampleStandardError", "error message")
         end
 
-        it "ignores Sidekiq::JobRetry::Skip errors" do
-          require "sidekiq"
-          require "sidekiq/job_retry"
+        context "Sidekiq internal errors" do
+          before do
+            require "sidekiq"
+            require "sidekiq/job_retry"
+          end
 
-          with_rails_error_reporter do
-            Rails.error.handle { raise Sidekiq::JobRetry::Skip, "error message" }
+          it "ignores Sidekiq::JobRetry::Handled errors" do
+            with_rails_error_reporter do
+              Rails.error.handle { raise Sidekiq::JobRetry::Handled, "error message" }
+            end
+
+            expect(last_transaction).to_not have_error
           end
 
-          expect(last_transaction).to_not have_error
+          it "ignores Sidekiq::JobRetry::Skip errors" do
+            with_rails_error_reporter do
+              Rails.error.handle { raise Sidekiq::JobRetry::Skip, "error message" }
+            end
+
+            expect(last_transaction).to_not have_error
+          end
+
+          it "doesn't crash when no Sidekiq error classes are found" do
+            hide_const("Sidekiq::JobRetry")
+            with_rails_error_reporter do
+              Rails.error.handle { raise ExampleStandardError, "error message" }
+            end
+
+            expect(last_transaction).to have_error("ExampleStandardError", "error message")
+          end
         end
 
         context "when no transaction is active" do

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

@@ -5,23 +5,29 @@ describe Appsignal::Rack::BodyWrapper do
     set_current_transaction(transaction)
   end
 
-  describe "with a body that supports all possible features" do
-    it "reduces the supported methods to just each()" do
-      # which is the safest thing to do, since the body is likely broken
-      fake_body = double(
-        :each => nil,
-        :call => nil,
-        :to_ary => [],
-        :to_path => "/tmp/foo.bin",
-        :close => nil
-      )
+  it "forwards method calls to the body if the method doesn't exist" do
+    fake_body = double(
+      :body => ["some body"],
+      :some_method => :some_value
+    )
+
+    wrapped = described_class.wrap(fake_body, transaction)
+    expect(wrapped).to respond_to(:body)
+    expect(wrapped.body).to eq(["some body"])
+
+    expect(wrapped).to respond_to(:some_method)
+    expect(wrapped.some_method).to eq(:some_value)
+  end
 
-      wrapped = described_class.wrap(fake_body, transaction)
-      expect(wrapped).to respond_to(:each)
-      expect(wrapped).to_not respond_to(:to_ary)
-      expect(wrapped).to_not respond_to(:call)
-      expect(wrapped).to respond_to(:close)
-    end
+  it "doesn't respond to methods the Rack::BodyProxy doesn't respond to" do
+    body = Rack::BodyProxy.new(["body"])
+    wrapped = described_class.wrap(body, transaction)
+
+    expect(wrapped).to_not respond_to(:to_str)
+    expect { wrapped.to_str }.to raise_error(NoMethodError)
+
+    expect(wrapped).to_not respond_to(:body)
+    expect { wrapped.body }.to raise_error(NoMethodError)
   end
 
   describe "with a body only supporting each()" do
@@ -97,15 +103,17 @@ describe Appsignal::Rack::BodyWrapper do
   end
 
   describe "with a body supporting both each() and call" do
-    it "wraps with the wrapper that conceals call() and exposes each" do
-      fake_body = double
-      allow(fake_body).to receive(:each)
-      allow(fake_body).to receive(:call)
+    it "wraps with the wrapper that exposes each" do
+      fake_body = double(
+        :each => true,
+        :call => "original call"
+      )
 
       wrapped = described_class.wrap(fake_body, transaction)
       expect(wrapped).to respond_to(:each)
       expect(wrapped).to_not respond_to(:to_ary)
-      expect(wrapped).to_not respond_to(:call)
+      expect(wrapped).to respond_to(:call)
+      expect(wrapped.call).to eq("original call")
       expect(wrapped).to_not respond_to(:to_path)
       expect(wrapped).to respond_to(:close)
     end

data/spec/lib/appsignal/transmitter_spec.rb

@@ -52,13 +52,41 @@ describe Appsignal::Transmitter do
         }
       ).to_return(:status => 200)
     end
-    let(:response) { instance.transmit(:the => :payload) }
+
+    let(:response) { instance.transmit({ :the => :payload }) }
 
     it "returns Net::HTTP response" do
       expect(response).to be_kind_of(Net::HTTPResponse)
       expect(response.code).to eq "200"
     end
 
+    describe "with :ndjson format" do
+      before do
+        stub_request(:post, "https://push.appsignal.com/1/action").with(
+          :query => {
+            :api_key => "abc",
+            :environment => "production",
+            :gem_version => Appsignal::VERSION,
+            :hostname => config[:hostname],
+            :name => "TestApp"
+          },
+          :body => "{\"the\":\"payload\"}\n{\"part\":\"two\"}",
+          :headers => {
+            "Content-Type" => "application/x-ndjson; charset=UTF-8"
+          }
+        ).to_return(:status => 200)
+      end
+
+      let(:response) do
+        instance.transmit([{ :the => :payload }, { :part => :two }], :format => :ndjson)
+      end
+
+      it "returns Net::HTTP response" do
+        expect(response).to be_kind_of(Net::HTTPResponse)
+        expect(response.code).to eq "200"
+      end
+    end
+
     context "with ca_file_path config option set" do
       context "when file does not exist" do
         before do
@@ -106,7 +134,7 @@ describe Appsignal::Transmitter do
   end
 
   describe "#http_post" do
-    subject { instance.send(:http_post, "the" => "payload") }
+    subject { instance.send(:http_post, { "the" => "payload" }, :format => :json) }
 
     it "sets the path" do
       expect(subject.path).to eq instance.uri.request_uri
@@ -115,6 +143,24 @@ describe Appsignal::Transmitter do
     it "sets the correct headers" do
       expect(subject["Content-Type"]).to eq "application/json; charset=UTF-8"
     end
+
+    it "serialises the payload to JSON" do
+      expect(subject.body).to eq "{\"the\":\"payload\"}"
+    end
+
+    describe "with :ndjson format" do
+      subject do
+        instance.send(:http_post, [{ "the" => "payload" }, { "part" => "two" }], :format => :ndjson)
+      end
+
+      it "sets the correct headers" do
+        expect(subject["Content-Type"]).to eq "application/x-ndjson; charset=UTF-8"
+      end
+
+      it "serialises the payload to NDJSON" do
+        expect(subject.body).to eq "{\"the\":\"payload\"}\n{\"part\":\"two\"}"
+      end
+    end
   end
 
   describe "#http_client" do

data/spec/lib/appsignal_spec.rb

@@ -581,6 +581,11 @@ describe Appsignal do
         expect(Appsignal.active?).to be_falsy
       end
     end
+
+    it "calls stop on the check-in scheduler" do
+      expect(Appsignal::CheckIn.scheduler).to receive(:stop)
+      Appsignal.stop
+    end
   end
 
   describe ".started?" do

data/spec/support/helpers/take_at_most_helper.rb

@@ -0,0 +1,21 @@
+module TakeAtMostHelper
+  # Assert that it takes at most a certain amount of time to run a block.
+  #
+  # @example
+  #  # Assert that it takes at most 1 second to run the block
+  #  take_at_most(1) { sleep 0.5 }
+  #
+  # @param time [Integer, Float] The maximum amount of time the block is allowed to
+  #  run in seconds.
+  # @yield Block to run.
+  # @raise [StandardError] Raises error if the block takes longer than the
+  #  specified time to run.
+  def take_at_most(time)
+    start = Time.now
+    yield
+    elapsed = Time.now - start
+    return if elapsed <= time
+
+    raise "Expected block to take at most #{time} seconds, but took #{elapsed}"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 4.0.4
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-23 00:00:00.000000000 Z
+date: 2024-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -202,6 +202,7 @@ files:
 - lib/appsignal/capistrano.rb
 - lib/appsignal/check_in.rb
 - lib/appsignal/check_in/cron.rb
+- lib/appsignal/check_in/scheduler.rb
 - lib/appsignal/cli.rb
 - lib/appsignal/cli/demo.rb
 - lib/appsignal/cli/diagnose.rb
@@ -309,6 +310,7 @@ files:
 - lib/appsignal/utils/integration_logger.rb
 - lib/appsignal/utils/integration_memory_logger.rb
 - lib/appsignal/utils/json.rb
+- lib/appsignal/utils/ndjson.rb
 - lib/appsignal/utils/query_params_sanitizer.rb
 - lib/appsignal/utils/rails_helper.rb
 - lib/appsignal/utils/stdout_and_logger_message.rb
@@ -322,7 +324,8 @@ files:
 - spec/lib/appsignal/auth_check_spec.rb
 - spec/lib/appsignal/capistrano2_spec.rb
 - spec/lib/appsignal/capistrano3_spec.rb
-- spec/lib/appsignal/check_in_spec.rb
+- spec/lib/appsignal/check_in/cron_spec.rb
+- spec/lib/appsignal/check_in/scheduler_spec.rb
 - spec/lib/appsignal/cli/demo_spec.rb
 - spec/lib/appsignal/cli/diagnose/paths_spec.rb
 - spec/lib/appsignal/cli/diagnose/utils_spec.rb
@@ -450,6 +453,7 @@ files:
 - spec/support/helpers/rails_helper.rb
 - spec/support/helpers/std_streams_helper.rb
 - spec/support/helpers/system_helpers.rb
+- spec/support/helpers/take_at_most_helper.rb
 - spec/support/helpers/time_helpers.rb
 - spec/support/helpers/transaction_helpers.rb
 - spec/support/helpers/wait_for_helper.rb

data/spec/lib/appsignal/check_in_spec.rb

@@ -1,136 +0,0 @@
-describe Appsignal::CheckIn::Cron do
-  let(:config) { project_fixture_config }
-  let(:cron_checkin) { described_class.new(:identifier => "cron-checkin-name") }
-  let(:transmitter) { Appsignal::Transmitter.new("http://cron_checkins/", config) }
-
-  before(:each) do
-    allow(Appsignal).to receive(:active?).and_return(true)
-    config.logger = Logger.new(StringIO.new)
-    allow(Appsignal::CheckIn::Cron).to receive(:transmitter).and_return(transmitter)
-  end
-
-  describe "when Appsignal is not active" do
-    it "should not transmit any events" do
-      allow(Appsignal).to receive(:active?).and_return(false)
-      expect(transmitter).not_to receive(:transmit)
-
-      cron_checkin.start
-      cron_checkin.finish
-    end
-  end
-
-  describe "#start" do
-    it "should send a cron check-in start" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "start",
-        :check_in_type => "cron"
-      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
-        "Transmitted cron check-in `cron-checkin-name` (#{cron_checkin.digest}) start event"
-      )
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      cron_checkin.start
-    end
-
-    it "should log an error if it fails" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "start",
-        :check_in_type => "cron"
-      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
-
-      expect(Appsignal.internal_logger).not_to receive(:debug)
-      expect(Appsignal.internal_logger).to receive(:error).with(
-        "Failed to transmit cron check-in start event: status code was 499"
-      )
-
-      cron_checkin.start
-    end
-  end
-
-  describe "#finish" do
-    it "should send a cron check-in finish" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "finish",
-        :check_in_type => "cron"
-      )).and_return(Net::HTTPResponse.new(nil, "200", nil))
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(
-        "Transmitted cron check-in `cron-checkin-name` (#{cron_checkin.digest}) finish event"
-      )
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      cron_checkin.finish
-    end
-
-    it "should log an error if it fails" do
-      expect(transmitter).to receive(:transmit).with(hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "finish",
-        :check_in_type => "cron"
-      )).and_return(Net::HTTPResponse.new(nil, "499", nil))
-
-      expect(Appsignal.internal_logger).not_to receive(:debug)
-      expect(Appsignal.internal_logger).to receive(:error).with(
-        "Failed to transmit cron check-in finish event: status code was 499"
-      )
-
-      cron_checkin.finish
-    end
-  end
-
-  describe ".cron" do
-    describe "when a block is given" do
-      it "should send a cron check-in start and finish and return the block output" do
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "start",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        )).and_return(nil)
-
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        )).and_return(nil)
-
-        output = Appsignal::CheckIn.cron("cron-checkin-with-block") { "output" }
-        expect(output).to eq("output")
-      end
-
-      it "should not send a cron check-in finish event when an error is raised" do
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "start",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        )).and_return(nil)
-
-        expect(transmitter).not_to receive(:transmit).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
-
-        expect do
-          Appsignal::CheckIn.cron("cron-checkin-with-block") { raise "error" }
-        end.to raise_error(RuntimeError, "error")
-      end
-    end
-
-    describe "when no block is given" do
-      it "should only send a cron check-in finish event" do
-        expect(transmitter).to receive(:transmit).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-without-block",
-          :check_in_type => "cron"
-        )).and_return(nil)
-
-        Appsignal::CheckIn.cron("cron-checkin-without-block")
-      end
-    end
-  end
-end