appsignal 4.0.0-java → 4.0.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b24fff89ddabacc2b97eedd0f2350e332084c31c4e879dab2b9f13e02f631e2
-  data.tar.gz: ec09dc858c399b9004cebb9afcdb1e041ba4f0efd068f173c6177e2bb5d10b1c
+  metadata.gz: 9a43d932132633873f343b1a180772e9949115f85fcce3d9e13d9af6a23eb824
+  data.tar.gz: 2d3d8fa4dfe45a3a42c89955bd243cd2c7871b3f2ac2978e7bef8333b6518b5e
 SHA512:
-  metadata.gz: 0ff5785db46ea54a79b993742b1f2730cae2bb236069c331414782732ed47de3a0c28a95e3bb8c9db45adcf2a402083af88f909d5065d839551d9f52bc560e64
-  data.tar.gz: 6da6a43068a8edf31158269f956be507f2125ec61dd8374192f228582c730862a5a659d5b2f530e7c995264e571d2e27daf049367089608dcdbbb63b5db16ef9
+  metadata.gz: a7f97a072db897dc6433d059067ad0bd0db054ec6d2b7a2f6c16ea9e8876e7b7f1b5ec3abdfba554fda60c6a211c8b3455a39221a9c7ebe8beb336a129fa0eec
+  data.tar.gz: 52e9a83f45fe345d895453e38833047c305f0b474918d8510148959a87a8e1ae797773213082152a03a19f8fd9cd7adfc37b5b0b6c33572f97fd9fdf3d67b5e1

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # AppSignal for Ruby gem Changelog
 
+## 4.0.2
+
+_Published on 2024-08-23._
+
+### Fixed
+
+- Do not log a warning for `nil` data being added as sample data, but silently ignore it because we don't support it. (patch [0a658e5e](https://github.com/appsignal/appsignal-ruby/commit/0a658e5e523f23f87b7d6e0b88bf6d6bea529f06))
+- Fix Rails session data not being reported. (patch [1565c7f0](https://github.com/appsignal/appsignal-ruby/commit/1565c7f0a55e8c2e51b615863b12d13a2b246949))
+
+## 4.0.1
+
+_Published on 2024-08-23._
+
+### Fixed
+
+- Do not report `Sidekiq::JobRetry::Skip` errors. These errors would be reported by our Rails error subscriber. This is an internal Sidekiq error we do not need to report. (patch [9ea2d3e8](https://github.com/appsignal/appsignal-ruby/commit/9ea2d3e83657d115baf166257a50c7e3394318aa))
+- Do not report `SystemExit` errors from our `at_exit` error reporter. (patch [e9c0cad3](https://github.com/appsignal/appsignal-ruby/commit/e9c0cad3d672e68a63ca9c33cfa30a3434c77d04))
+
 ## 4.0.0
 
 _Published on 2024-08-23._

data/lib/appsignal/hooks/at_exit.rb

@@ -24,6 +24,7 @@ module Appsignal
       class AtExitCallback
         def self.call
           error = $! # rubocop:disable Style/SpecialGlobalVars
+          return if ignored_error?(error)
           return if Appsignal::Transaction.last_errors.include?(error)
 
           Appsignal.report_error(error) do |transaction|
@@ -31,6 +32,15 @@ module Appsignal
           end
           Appsignal.stop("at_exit")
         end
+
+        IGNORED_ERRORS = [
+          # Normal exits from the application we do not need to report
+          SystemExit
+        ].freeze
+
+        def self.ignored_error?(error)
+          IGNORED_ERRORS.include?(error.class)
+        end
       end
     end
   end

data/lib/appsignal/integrations/railtie.rb

@@ -80,6 +80,8 @@ module Appsignal
     class RailsErrorReporterSubscriber
       class << self
         def report(error, handled:, severity:, context: {}, source: nil) # rubocop:disable Lint/UnusedMethodArgument
+          return if ignored_error?(error)
+
           is_rails_runner = source == "application.runner.railties"
           namespace, action_name, tags, custom_data = context_for(context.dup)
 
@@ -100,6 +102,16 @@ module Appsignal
 
         private
 
+        IGNORED_ERRORS = [
+          # We don't need to alert Sidekiq job skip errors.
+          # This is an internal Sidekiq error.
+          "Sidekiq::JobRetry::Skip"
+        ].freeze
+
+        def ignored_error?(error)
+          IGNORED_ERRORS.include?(error.class.name)
+        end
+
         def context_for(context)
           tags = {}
 

data/lib/appsignal/rack/abstract_middleware.rb

@@ -142,9 +142,7 @@ module Appsignal
         transaction.set_metadata("method", request_method) if request_method
 
         transaction.add_params { params_for(request) }
-        transaction.add_session_data do
-          request.session if request.respond_to?(:session)
-        end
+        transaction.add_session_data { session_data_for(request) }
         transaction.add_headers do
           request.env if request.respond_to?(:env)
         end
@@ -174,6 +172,18 @@ module Appsignal
         nil
       end
 
+      def session_data_for(request)
+        return unless request.respond_to?(:session)
+
+        request.session.to_h
+      rescue => error
+        Appsignal.internal_logger.error(
+          "Exception while fetching session data from '#{@request_class}': " \
+            "#{error.class} #{error}"
+        )
+        nil
+      end
+
       def request_for(env)
         @request_class.new(env)
       end

data/lib/appsignal/sample_data.rb

@@ -28,7 +28,7 @@ module Appsignal
     end
 
     def value
-      value = nil
+      value = UNSET_VALUE
       @blocks.map! do |block_or_value|
         new_value =
           if block_or_value.respond_to?(:call)
@@ -63,6 +63,8 @@ module Appsignal
 
     private
 
+    UNSET_VALUE = nil
+
     # Method called by `dup` and `clone` to create a duplicate instance.
     # Make sure the `@blocks` variable is also properly duplicated.
     def initialize_copy(original)
@@ -81,11 +83,13 @@ module Appsignal
 
     def merge_values(value_original, value_new)
       unless value_new.instance_of?(value_original.class)
-        Appsignal.internal_logger.warn(
-          "The sample data '#{@key}' changed type from " \
-            "'#{value_original.class}' to '#{value_new.class}'. " \
-            "These types can not be merged. Using new '#{value_new.class}' type."
-        )
+        unless value_original == UNSET_VALUE
+          Appsignal.internal_logger.warn(
+            "The sample data '#{@key}' changed type from " \
+              "'#{value_original.class}' to '#{value_new.class}'. " \
+              "These types can not be merged. Using new '#{value_new.class}' type."
+          )
+        end
         return value_new
       end
 

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "4.0.0"
+  VERSION = "4.0.2"
 end

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

@@ -59,7 +59,7 @@ describe Appsignal::Hooks::AtExit::AtExitCallback do
     end
   end
 
-  it "doesn't report the error if is also the last error reported" do
+  it "doesn't report the error if it is also the last error reported" do
     with_error(ExampleException, "error message") do |error|
       Appsignal.report_error(error)
       expect(created_transactions.count).to eq(1)
@@ -69,4 +69,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 SystemExit exception" do
+    with_error(SystemExit, "error message") 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/hooks/resque_spec.rb

@@ -17,154 +17,10 @@ describe Appsignal::Hooks::ResqueHook do
 
   if DependencyHelper.resque_present?
     describe "#install" do
-      def perform_rescue_job(klass, options = {})
-        payload = { "class" => klass.to_s }.merge(options)
-        job = ::Resque::Job.new(queue, payload)
-        keep_transactions { job.perform }
-      end
-
-      let(:queue) { "default" }
-      let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
-      let(:options) { {} }
-      before do
-        start_agent(:options => options)
-
-        class ResqueTestJob
-          def self.perform(*_args)
-          end
-        end
-
-        class ResqueErrorTestJob
-          def self.perform
-            raise "resque job error"
-          end
-        end
-
-        expect(Appsignal).to receive(:stop) # Resque calls stop after every job
-      end
-      around do |example|
-        keep_transactions { example.run }
-      end
-      after do
-        Object.send(:remove_const, :ResqueTestJob)
-        Object.send(:remove_const, :ResqueErrorTestJob)
-      end
-
-      it "tracks a transaction on perform" do
-        perform_rescue_job(ResqueTestJob)
-
-        transaction = last_transaction
-        expect(transaction).to have_id
-        expect(transaction).to have_namespace(namespace)
-        expect(transaction).to have_action("ResqueTestJob#perform")
-        expect(transaction).to_not have_error
-        expect(transaction).to_not include_metadata
-        expect(transaction).to_not include_breadcrumbs
-        expect(transaction).to include_tags("queue" => queue)
-        expect(transaction).to include_event("name" => "perform.resque")
-      end
-
-      context "with error" do
-        it "tracks the error on the transaction" do
-          expect do
-            perform_rescue_job(ResqueErrorTestJob)
-          end.to raise_error(RuntimeError, "resque job error")
-
-          transaction = last_transaction
-          expect(transaction).to have_id
-          expect(transaction).to have_namespace(namespace)
-          expect(transaction).to have_action("ResqueErrorTestJob#perform")
-          expect(transaction).to have_error("RuntimeError", "resque job error")
-          expect(transaction).to_not include_metadata
-          expect(transaction).to_not include_breadcrumbs
-          expect(transaction).to include_tags("queue" => queue)
-          expect(transaction).to include_event("name" => "perform.resque")
-        end
-      end
-
-      context "with arguments" do
-        let(:options) { { :filter_parameters => ["foo"] } }
-
-        it "filters out configured arguments" do
-          perform_rescue_job(
-            ResqueTestJob,
-            "args" => [
-              "foo",
-              {
-                "foo" => "secret",
-                "bar" => "Bar",
-                "baz" => { "1" => "foo" }
-              }
-            ]
-          )
-
-          transaction = last_transaction
-          expect(transaction).to have_id
-          expect(transaction).to have_namespace(namespace)
-          expect(transaction).to have_action("ResqueTestJob#perform")
-          expect(transaction).to_not have_error
-          expect(transaction).to_not include_metadata
-          expect(transaction).to_not include_breadcrumbs
-          expect(transaction).to include_tags("queue" => queue)
-          expect(transaction).to include_event("name" => "perform.resque")
-          expect(transaction).to include_params(
-            [
-              "foo",
-              {
-                "foo" => "[FILTERED]",
-                "bar" => "Bar",
-                "baz" => { "1" => "foo" }
-              }
-            ]
-          )
-        end
-      end
-
-      context "with active job" do
-        before do
-          module ActiveJobMock
-            module QueueAdapters
-              module ResqueAdapter
-                module JobWrapper
-                  class << self
-                    def perform(job_data)
-                      # Basic ActiveJob stub for this test.
-                      # I haven't found a way to run Resque in a testing mode.
-                      Appsignal.set_action(job_data["job_class"])
-                    end
-                  end
-                end
-              end
-            end
-          end
-
-          stub_const "ActiveJob", ActiveJobMock
-        end
-        after { Object.send(:remove_const, :ActiveJobMock) }
-
-        it "does not set arguments but lets the ActiveJob integration handle it" do
-          perform_rescue_job(
-            ResqueTestJob,
-            "class" => "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper",
-            "args" => [
-              {
-                "job_class" => "ResqueTestJobByActiveJob#perform",
-                "arguments" => ["an argument", "second argument"]
-              }
-            ]
-          )
+      before { start_agent }
 
-          transaction = last_transaction
-          expect(transaction).to have_id
-          expect(transaction).to have_namespace(namespace)
-          expect(transaction).to have_action("ResqueTestJobByActiveJob#perform")
-          expect(transaction).to_not have_error
-          expect(transaction).to_not include_metadata
-          expect(transaction).to_not include_breadcrumbs
-          expect(transaction).to include_tags("queue" => queue)
-          expect(transaction).to include_event("name" => "perform.resque")
-          expect(transaction).to_not include_params
-        end
+      it "adds the ResqueIntegration module to Resque::Job" do
+        expect(Resque::Job.included_modules).to include(Appsignal::Integrations::ResqueIntegration)
       end
     end
   end

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

@@ -229,6 +229,17 @@ 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"
+
+          with_rails_error_reporter do
+            Rails.error.handle { raise Sidekiq::JobRetry::Skip, "error message" }
+          end
+
+          expect(last_transaction).to_not have_error
+        end
+
         context "when no transaction is active" do
           it "reports the error on a new transaction" do
             with_rails_error_reporter do

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

@@ -0,0 +1,155 @@
+require "appsignal/integrations/resque"
+
+if DependencyHelper.resque_present?
+  describe Appsignal::Integrations::ResqueIntegration do
+    def perform_rescue_job(klass, options = {})
+      payload = { "class" => klass.to_s }.merge(options)
+      job = ::Resque::Job.new(queue, payload)
+      keep_transactions { job.perform }
+    end
+
+    let(:queue) { "default" }
+    let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+    let(:options) { {} }
+    before do
+      start_agent(:options => options)
+
+      class ResqueTestJob
+        def self.perform(*_args)
+        end
+      end
+
+      class ResqueErrorTestJob
+        def self.perform
+          raise "resque job error"
+        end
+      end
+
+      expect(Appsignal).to receive(:stop) # Resque calls stop after every job
+    end
+    around do |example|
+      keep_transactions { example.run }
+    end
+    after do
+      Object.send(:remove_const, :ResqueTestJob)
+      Object.send(:remove_const, :ResqueErrorTestJob)
+    end
+
+    it "tracks a transaction on perform" do
+      perform_rescue_job(ResqueTestJob)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_namespace(namespace)
+      expect(transaction).to have_action("ResqueTestJob#perform")
+      expect(transaction).to_not have_error
+      expect(transaction).to_not include_metadata
+      expect(transaction).to_not include_breadcrumbs
+      expect(transaction).to include_tags("queue" => queue)
+      expect(transaction).to include_event("name" => "perform.resque")
+    end
+
+    context "with error" do
+      it "tracks the error on the transaction" do
+        expect do
+          perform_rescue_job(ResqueErrorTestJob)
+        end.to raise_error(RuntimeError, "resque job error")
+
+        transaction = last_transaction
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(namespace)
+        expect(transaction).to have_action("ResqueErrorTestJob#perform")
+        expect(transaction).to have_error("RuntimeError", "resque job error")
+        expect(transaction).to_not include_metadata
+        expect(transaction).to_not include_breadcrumbs
+        expect(transaction).to include_tags("queue" => queue)
+        expect(transaction).to include_event("name" => "perform.resque")
+      end
+    end
+
+    context "with arguments" do
+      let(:options) { { :filter_parameters => ["foo"] } }
+
+      it "filters out configured arguments" do
+        perform_rescue_job(
+          ResqueTestJob,
+          "args" => [
+            "foo",
+            {
+              "foo" => "secret",
+              "bar" => "Bar",
+              "baz" => { "1" => "foo" }
+            }
+          ]
+        )
+
+        transaction = last_transaction
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(namespace)
+        expect(transaction).to have_action("ResqueTestJob#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to_not include_metadata
+        expect(transaction).to_not include_breadcrumbs
+        expect(transaction).to include_tags("queue" => queue)
+        expect(transaction).to include_event("name" => "perform.resque")
+        expect(transaction).to include_params(
+          [
+            "foo",
+            {
+              "foo" => "[FILTERED]",
+              "bar" => "Bar",
+              "baz" => { "1" => "foo" }
+            }
+          ]
+        )
+      end
+    end
+
+    context "with active job" do
+      before do
+        module ActiveJobMock
+          module QueueAdapters
+            module ResqueAdapter
+              module JobWrapper
+                class << self
+                  def perform(job_data)
+                    # Basic ActiveJob stub for this test.
+                    # I haven't found a way to run Resque in a testing mode.
+                    Appsignal.set_action(job_data["job_class"])
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        stub_const "ActiveJob", ActiveJobMock
+      end
+      after { Object.send(:remove_const, :ActiveJobMock) }
+
+      it "does not set arguments but lets the ActiveJob integration handle it" do
+        perform_rescue_job(
+          ResqueTestJob,
+          "class" => "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper",
+          "args" => [
+            {
+              "job_class" => "ResqueTestJobByActiveJob#perform",
+              "arguments" => ["an argument", "second argument"]
+            }
+          ]
+        )
+
+        transaction = last_transaction
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(namespace)
+        expect(transaction).to have_action("ResqueTestJobByActiveJob#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to_not include_metadata
+        expect(transaction).to_not include_breadcrumbs
+        expect(transaction).to include_tags("queue" => queue)
+        expect(transaction).to include_event("name" => "perform.resque")
+        expect(transaction).to_not include_params
+      end
+    end
+  end
+end

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

@@ -1,4 +1,14 @@
 describe Appsignal::Rack::AbstractMiddleware do
+  class HashLike < Hash
+    def initialize(value)
+      @value = value
+    end
+
+    def to_h
+      @value
+    end
+  end
+
   let(:app) { DummyApp.new }
   let(:request_path) { "/some/path" }
   let(:env) do
@@ -261,6 +271,13 @@ describe Appsignal::Rack::AbstractMiddleware do
 
           expect(last_transaction).to include_session_data("session" => "data", "user_id" => 123)
         end
+
+        it "sets session data if the session is a Hash-like type" do
+          env["rack.session"] = HashLike.new("hash-like" => "value", "user_id" => 123)
+          make_request
+
+          expect(last_transaction).to include_session_data("hash-like" => "value", "user_id" => 123)
+        end
       end
 
       context "with queue start header" do

data/spec/lib/appsignal/sample_data_spec.rb

@@ -3,9 +3,17 @@ describe Appsignal::SampleData do
 
   describe "#add" do
     it "sets the given value" do
-      data.add(:key1 => "value 1")
+      logs =
+        capture_logs do
+          data.add(:key1 => "value 1")
+        end
 
       expect(data.value).to eq(:key1 => "value 1")
+
+      expect(logs).to_not contains_log(
+        :error,
+        "Sample data 'data_key': Unsupported data type 'NilClass' received: nil"
+      )
     end
 
     it "adds the given value with the block being leading" do
@@ -14,6 +22,23 @@ describe Appsignal::SampleData do
       expect(data.value).to eq(:key2 => "value 2")
     end
 
+    it "doesn't add nil to the data" do
+      logs =
+        capture_logs do
+          data.add([1])
+          data.add(nil)
+          data.add { nil }
+          data.add([2, 3])
+        end
+
+      expect(data.value).to eq([1, 2, 3])
+      expect(logs).to contains_log(
+        :error,
+        "Sample data 'data_key': Unsupported data type 'NilClass' received: nil"
+      )
+      expect(logs).to_not contains_log(:warn, "The sample data 'data_key' changed type")
+    end
+
     it "merges multiple values" do
       data.add(:key1 => "value 1")
       data.add(:key2 => "value 2")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.2
 platform: java
 authors:
 - Robert Beekman
@@ -386,6 +386,7 @@ files:
 - spec/lib/appsignal/integrations/object_spec.rb
 - spec/lib/appsignal/integrations/que_spec.rb
 - spec/lib/appsignal/integrations/railtie_spec.rb
+- spec/lib/appsignal/integrations/resque_spec.rb
 - spec/lib/appsignal/integrations/shoryuken_spec.rb
 - spec/lib/appsignal/integrations/sidekiq_spec.rb
 - spec/lib/appsignal/integrations/webmachine_spec.rb