appsignal 3.4.0 → 3.4.1

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

@@ -153,7 +153,8 @@ if DependencyHelper.grape_present?
           end
 
           it "sets non-unique route_param path" do
-            expect(transaction).to receive(:set_action_if_nil).with("GET::GrapeExample::Api#/users/:id/")
+            expect(transaction).to receive(:set_action_if_nil)
+              .with("GET::GrapeExample::Api#/users/:id/")
             expect(transaction).to receive(:set_metadata).with("path", "/users/:id/")
             expect(transaction).to receive(:set_metadata).with("method", "GET")
           end
@@ -177,7 +178,8 @@ if DependencyHelper.grape_present?
             end
 
             it "sets namespaced path" do
-              expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
+              expect(transaction).to receive(:set_action_if_nil)
+                .with("POST::GrapeExample::Api#/v1/beta/ping")
               expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
               expect(transaction).to receive(:set_metadata).with("method", "POST")
             end
@@ -199,7 +201,8 @@ if DependencyHelper.grape_present?
               end
 
               it "sets namespaced path" do
-                expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_action_if_nil)
+                  .with("POST::GrapeExample::Api#/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("method", "POST")
               end
@@ -220,7 +223,8 @@ if DependencyHelper.grape_present?
               end
 
               it "sets namespaced path" do
-                expect(transaction).to receive(:set_action_if_nil).with("POST::GrapeExample::Api#/v1/beta/ping")
+                expect(transaction).to receive(:set_action_if_nil)
+                  .with("POST::GrapeExample::Api#/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("path", "/v1/beta/ping")
                 expect(transaction).to receive(:set_metadata).with("method", "POST")
               end

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

@@ -20,14 +20,16 @@ if DependencyHelper.hanami2_present?
       end
 
       it "prepends the integration to Hanami" do
-        expect(::Hanami::Action).to receive(:send).with(:prepend, Appsignal::Integrations::HanamiIntegration)
+        expect(::Hanami::Action).to receive(:prepend)
+          .with(Appsignal::Integrations::HanamiIntegration)
       end
 
       context "when not active" do
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
         it "does not prepend the integration" do
-          expect(::Hanami::Action).to_not receive(:send).with(:prepend, Appsignal::Integrations::HanamiIntegration)
+          expect(::Hanami::Action).to_not receive(:prepend)
+            .with(Appsignal::Integrations::HanamiIntegration)
         end
       end
 
@@ -71,17 +73,22 @@ if DependencyHelper.hanami2_present?
         end
 
         it "sets the action name" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil).with("HanamiApp::Actions::Books::Index")
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil)
+            .with("HanamiApp::Actions::Books::Index")
         end
 
         it "sets the metadata" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).with("status", "200")
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).with("path", "/books")
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).with("method", "GET")
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
+            .with("status", "200")
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
+            .with("path", "/books")
+          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
+            .with("method", "GET")
         end
 
         it "sets the queue start" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_http_or_background_queue_start)
+          expect_any_instance_of(Appsignal::Transaction)
+            .to receive(:set_http_or_background_queue_start)
         end
 
         context "with error", :error => true do
@@ -92,7 +99,8 @@ if DependencyHelper.hanami2_present?
           end
 
           it "sets the status to 500" do
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).with("status", "500")
+            expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
+              .with("status", "500")
             expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
           end
         end

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

@@ -19,11 +19,8 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
       it "should sanitize command" do
         # TODO: additional curly brackets required for issue
         # https://github.com/rspec/rspec-mocks/issues/1460
-        # rubocop:disable Style/BracesAroundHashParameters
         expect(Appsignal::EventFormatter::MongoRubyDriver::QueryFormatter)
           .to receive(:format).with("find", { "foo" => "bar" })
-        # rubocop:enable Style/BracesAroundHashParameters
-
         subscriber.started(event)
       end
 
@@ -107,7 +104,8 @@ describe Appsignal::Hooks::MongoMonitorSubscriber do
 
   context "without transaction" do
     before do
-      allow(Appsignal::Transaction).to receive(:current).and_return(Appsignal::Transaction::NilTransaction.new)
+      allow(Appsignal::Transaction).to receive(:current)
+        .and_return(Appsignal::Transaction::NilTransaction.new)
     end
 
     it "should not attempt to start an event" do

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

@@ -25,7 +25,8 @@ describe Object do
         let(:transaction) { http_request_transaction }
         before do
           Appsignal.config = project_fixture_config
-          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+          expect(Appsignal::Transaction).to receive(:current)
+            .at_least(:once).and_return(transaction)
           expect(Appsignal.active?).to be_truthy
         end
         after { Appsignal.config = nil }
@@ -43,9 +44,11 @@ describe Object do
               end
               appsignal_instrument_method :positional_arguments_splat
 
+              # rubocop:disable Naming/MethodParameterName
               def keyword_arguments(a: nil, b: nil)
                 [a, b]
               end
+              # rubocop:enable Naming/MethodParameterName
               appsignal_instrument_method :keyword_arguments
 
               def keyword_arguments_splat(**kwargs)
@@ -213,9 +216,11 @@ describe Object do
               end
               appsignal_instrument_class_method :positional_arguments_splat
 
+              # rubocop:disable Naming/MethodParameterName
               def self.keyword_arguments(a: nil, b: nil)
                 [a, b]
               end
+              # rubocop:enable Naming/MethodParameterName
               appsignal_instrument_class_method :keyword_arguments
 
               def self.keyword_arguments_splat(**kwargs)

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

@@ -283,7 +283,8 @@ if DependencyHelper.padrino_present?
 
                   it "sets the action with the app name, controller name and action name" do
                     expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:my_controller#index")
+                    expect(transaction).to receive(:set_action_if_nil)
+                      .with("PadrinoTestApp:my_controller#index")
                   end
                 end
 
@@ -295,7 +296,8 @@ if DependencyHelper.padrino_present?
 
                   it "sets the action with the app name, controller name and action path" do
                     expect_a_transaction_to_be_created
-                    expect(transaction).to receive(:set_action_if_nil).with("PadrinoTestApp:/my_controller#index")
+                    expect(transaction).to receive(:set_action_if_nil)
+                      .with("PadrinoTestApp:/my_controller#index")
                   end
                 end
               end

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

@@ -1,4 +1,6 @@
 if DependencyHelper.rails_present?
+  require "action_mailer"
+
   describe Appsignal::Integrations::Railtie do
     context "after initializing the app" do
       it "should call initialize_appsignal" do
@@ -10,11 +12,7 @@ if DependencyHelper.rails_present?
     end
 
     describe "#initialize_appsignal" do
-      let(:app) { MyApp::Application }
-      before do
-        allow(app.middleware).to receive(:insert_before)
-        allow(app.middleware).to receive(:insert_after)
-      end
+      let(:app) { MyApp::Application.new }
 
       describe ".logger" do
         before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
@@ -58,6 +56,52 @@ if DependencyHelper.rails_present?
             expect(config.env).to eq "env_test"
           end
         end
+
+        if Rails.respond_to?(:error)
+          context "when Rails listens to `error`" do
+            class ErrorReporterMock
+              attr_reader :subscribers
+
+              def initialize
+                @subscribers = []
+              end
+
+              def subscribe(subscriber)
+                @subscribers << subscriber
+              end
+            end
+
+            let(:error_reporter) { ErrorReporterMock.new }
+            before do
+              allow(Rails).to receive(:error).and_return(error_reporter)
+            end
+
+            context "when enable_rails_error_reporter is enabled" do
+              it "subscribes to the error reporter" do
+                Appsignal::Integrations::Railtie.initialize_appsignal(app)
+
+                expect(error_reporter.subscribers)
+                  .to eq([Appsignal::Integrations::RailsErrorReporterSubscriber])
+              end
+            end
+
+            context "when enable_rails_error_reporter is disabled" do
+              it "does not subscribe to the error reporter" do
+                ENV["APPSIGNAL_ENABLE_RAILS_ERROR_REPORTER"] = "false"
+                Appsignal::Integrations::Railtie.initialize_appsignal(app)
+
+                expect(error_reporter.subscribers)
+                  .to_not eq([Appsignal::Integrations::RailsErrorReporterSubscriber])
+              end
+            end
+          end
+        else
+          context "when Rails does not listen to `error`" do
+            it "does not error trying to subscribe to the error reporter" do
+              Appsignal::Integrations::Railtie.initialize_appsignal(app)
+            end
+          end
+        end
       end
 
       describe ".initial_config" do
@@ -75,9 +119,172 @@ if DependencyHelper.rails_present?
             ActionDispatch::DebugExceptions,
             Appsignal::Rack::RailsInstrumentation
           )
+          Appsignal::Integrations::Railtie.initialize_appsignal(app)
         end
+      end
+
+      if Rails.respond_to?(:error)
+        describe "Rails error reporter" do
+          before do
+            Appsignal::Integrations::Railtie.initialize_appsignal(app)
+            start_agent
+          end
+          around { |example| keep_transactions { example.run } }
+
+          context "when error is not handled (reraises the error)" do
+            it "does nothing" do
+              expect do
+                Rails.error.record { raise ExampleStandardError }
+              end.to raise_error(ExampleStandardError)
+
+              expect(created_transactions).to be_empty
+            end
+          end
 
-        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+          context "when error is handled (not reraised)" do
+            context "when a transaction is active" do
+              it "duplicates the transaction namespace, action and tags" do
+                current_transaction = http_request_transaction
+                current_transaction.set_namespace "custom"
+                current_transaction.set_action "CustomAction"
+                current_transaction.set_tags(
+                  :duplicated_tag => "duplicated value"
+                )
+
+                with_current_transaction current_transaction do
+                  Rails.error.handle { raise ExampleStandardError }
+
+                  transaction = last_transaction
+                  transaction_hash = transaction.to_h
+                  expect(transaction_hash).to include(
+                    "action" => "CustomAction",
+                    "namespace" => "custom",
+                    "error" => {
+                      "name" => "ExampleStandardError",
+                      "message" => "ExampleStandardError",
+                      "backtrace" => kind_of(String)
+                    },
+                    "sample_data" => hash_including(
+                      "tags" => {
+                        "duplicated_tag" => "duplicated value",
+                        "severity" => "warning"
+                      }
+                    )
+                  )
+                end
+              end
+
+              it "overwrites duplicated tags with tags from context" do
+                current_transaction = http_request_transaction
+                current_transaction.set_tags(:tag1 => "duplicated value")
+
+                with_current_transaction current_transaction do
+                  given_context = { :tag1 => "value1", :tag2 => "value2" }
+                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+
+                  transaction = last_transaction
+                  transaction_hash = transaction.to_h
+                  expect(transaction_hash).to include(
+                    "sample_data" => hash_including(
+                      "tags" => {
+                        "tag1" => "value1",
+                        "tag2" => "value2",
+                        "severity" => "warning"
+                      }
+                    )
+                  )
+                end
+              end
+
+              it "overwrites duplicated namespace and action with custom from context" do
+                current_transaction = http_request_transaction
+                current_transaction.set_namespace "custom"
+                current_transaction.set_action "CustomAction"
+
+                with_current_transaction current_transaction do
+                  given_context = {
+                    :appsignal => { :namespace => "context", :action => "ContextAction" }
+                  }
+                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+
+                  transaction = last_transaction
+                  transaction_hash = transaction.to_h
+                  expect(transaction_hash).to include(
+                    "namespace" => "context",
+                    "action" => "ContextAction"
+                  )
+                end
+              end
+            end
+
+            context "when no transaction is active" do
+              class ExampleRailsControllerMock
+                def action_name
+                  "index"
+                end
+              end
+
+              class ExampleRailsJobMock
+              end
+
+              class ExampleRailsMailerMock < ActionMailer::MailDeliveryJob
+                def arguments
+                  ["ExampleRailsMailerMock", "send_mail"]
+                end
+              end
+
+              before do
+                clear_current_transaction!
+              end
+
+              it "fetches the action from the controller in the context" do
+                # The controller key is set by Rails when raised in a controller
+                given_context = { :controller => ExampleRailsControllerMock.new }
+                Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+
+                transaction = last_transaction
+                transaction_hash = transaction.to_h
+                expect(transaction_hash).to include(
+                  "action" => "ExampleRailsControllerMock#index"
+                )
+              end
+
+              it "sets no action if no execution context is present" do
+                # The controller key is set by Rails when raised in a controller
+                Rails.error.handle { raise ExampleStandardError }
+
+                transaction = last_transaction
+                transaction_hash = transaction.to_h
+                expect(transaction_hash).to include(
+                  "action" => nil
+                )
+              end
+            end
+
+            it "sets the error context as tags" do
+              given_context = {
+                :controller => ExampleRailsControllerMock.new, # Not set as tag
+                :job => ExampleRailsJobMock.new, # Not set as tag
+                :appsignal => { :something => "not used" }, # Not set as tag
+                :tag1 => "value1",
+                :tag2 => "value2"
+              }
+              Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+
+              transaction = last_transaction
+              transaction_hash = transaction.to_h
+              expect(transaction_hash).to include(
+                "sample_data" => hash_including(
+                  "tags" => {
+                    "tag1" => "value1",
+                    "tag2" => "value2",
+                    "severity" => "warning"
+                  }
+                )
+              )
+            end
+          end
+        end
       end
     end
   end

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

@@ -10,11 +10,9 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
 
   context "without a current transction" do
     let(:exception) do
-      begin
-        raise ExampleStandardError, "uh oh"
-      rescue => error
-        error
-      end
+      raise ExampleStandardError, "uh oh"
+    rescue => error
+      error
     end
     let(:job_context) do
       {
@@ -74,14 +72,14 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
   let(:jid) { "b4a577edbccf1d805744efa9" }
   let(:item) do
     {
-      "jid"         => jid,
-      "class"       => job_class,
+      "jid" => jid,
+      "class" => job_class,
       "retry_count" => 0,
-      "queue"       => "default",
-      "created_at"  => Time.parse("2001-01-01 10:00:00UTC").to_f,
+      "queue" => "default",
+      "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
       "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-      "args"        => given_args,
-      "extra"       => "data"
+      "args" => given_args,
+      "extra" => "data"
     }
   end
   let(:plugin) { Appsignal::Integrations::SidekiqMiddleware.new }
@@ -230,13 +228,10 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     it "creates a transaction and adds the error" do
       # TODO: additional curly brackets required for issue
       # https://github.com/rspec/rspec-mocks/issues/1460
-      # rubocop:disable Style/BracesAroundHashParameters
       expect(Appsignal).to receive(:increment_counter)
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :failed })
       expect(Appsignal).to receive(:increment_counter)
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :processed })
-      # rubocop:enable Style/BracesAroundHashParameters
-
       expect do
         perform_job { raise error, "uh oh" }
       end.to raise_error(error)
@@ -269,15 +264,40 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
     end
   end
 
+  if DependencyHelper.rails7_present?
+    context "with Rails error reporter" do
+      it "reports the worker name as the action, copies the namespace and tags" do
+        Appsignal::Integrations::Railtie.initialize_appsignal(MyApp::Application.new)
+        Appsignal.config = project_fixture_config("production")
+        perform_job do
+          Appsignal.tag_job("test_tag" => "value")
+          Rails.error.handle do
+            raise error, "uh oh"
+          end
+        end
+
+        expect(created_transactions.count).to eq(2)
+        expected_transaction = {
+          "namespace" => "background_job",
+          "action" => "TestClass#perform",
+          "sample_data" => hash_including(
+            "tags" => hash_including("test_tag" => "value")
+          )
+        }
+        sidekiq_transaction = created_transactions.first.to_h
+        error_reporter_transaction = created_transactions.last.to_h
+        expect(sidekiq_transaction).to include(expected_transaction)
+        expect(error_reporter_transaction).to include(expected_transaction)
+      end
+    end
+  end
+
   context "without an error" do
     it "creates a transaction with events" do
       # TODO: additional curly brackets required for issue
       # https://github.com/rspec/rspec-mocks/issues/1460
-      # rubocop:disable Style/BracesAroundHashParameters
       expect(Appsignal).to receive(:increment_counter)
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :processed })
-      # rubocop:enable Style/BracesAroundHashParameters
-
       perform_job
 
       transaction_hash = transaction.to_h
@@ -309,18 +329,14 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
 
   def perform_job
     Timecop.freeze(Time.parse("2001-01-01 10:01:00UTC")) do
-      begin
-        exception = nil
-        plugin.call(worker, item, queue) do
-          yield if block_given?
-        end
-      rescue Exception => exception # rubocop:disable Lint/RescueException
-        raise exception
-      ensure
-        if exception
-          Appsignal::Integrations::SidekiqErrorHandler.new.call(exception, :job => item)
-        end
+      exception = nil
+      plugin.call(worker, item, queue) do
+        yield if block_given?
       end
+    rescue Exception => exception # rubocop:disable Lint/RescueException
+      raise exception
+    ensure
+      Appsignal::Integrations::SidekiqErrorHandler.new.call(exception, :job => item) if exception
     end
   end
 
@@ -516,7 +532,8 @@ if DependencyHelper.active_job_present?
         expect(transaction_hash).to include(
           "action" => "ActionMailerSidekiqTestJob#welcome",
           "sample_data" => hash_including(
-            "params" => ["ActionMailerSidekiqTestJob", "welcome", "deliver_now"] + expected_wrapped_args
+            "params" => ["ActionMailerSidekiqTestJob", "welcome",
+                         "deliver_now"] + expected_wrapped_args
           )
         )
       end
@@ -524,18 +541,14 @@ if DependencyHelper.active_job_present?
 
     def perform_sidekiq
       Timecop.freeze(time) do
-        begin
-          yield
-          # Combined with Sidekiq::Testing.fake! and drain_all we get a
-          # enqueue_at in the job data.
-          Sidekiq::Worker.drain_all
-        rescue Exception => exception # rubocop:disable Lint/RescueException
-          raise exception
-        ensure
-          if exception
-            Appsignal::Integrations::SidekiqErrorHandler.new.call(exception, {})
-          end
-        end
+        yield
+        # Combined with Sidekiq::Testing.fake! and drain_all we get a
+        # enqueue_at in the job data.
+        Sidekiq::Worker.drain_all
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        raise exception
+      ensure
+        Appsignal::Integrations::SidekiqErrorHandler.new.call(exception, {}) if exception
       end
     end
 

data/spec/lib/appsignal/logger_spec.rb

@@ -60,13 +60,31 @@ describe Appsignal::Logger do
       end
 
       it "should log with a level, message and group" do
-        expect(Appsignal::Extension).to receive(:log)
-          .with("other_group", 3, 0, "formatted: 'Log message'", instance_of(Appsignal::Extension::Data))
+        expect(Appsignal::Extension).to receive(:log).with(
+          "other_group",
+          3,
+          0,
+          "formatted: 'Log message'",
+          instance_of(Appsignal::Extension::Data)
+        )
         logger.add(::Logger::INFO, "Log message", "other_group")
       end
     end
   end
 
+  describe "#silence" do
+    it "calls the given block" do
+      num = 1
+
+      logger.silence do
+        num += 1
+      end
+
+      expect(num).to eq(2)
+      expect(Appsignal::Extension).not_to receive(:log)
+    end
+  end
+
   [
     ["debug", 2, ::Logger::INFO],
     ["info", 3, ::Logger::WARN],
@@ -76,11 +94,9 @@ describe Appsignal::Logger do
   ].each do |method|
     describe "##{method[0]}" do
       it "should log with a message" do
-        # rubocop:disable Style/BracesAroundHashParameters
         expect(Appsignal::Utils::Data).to receive(:generate)
           .with({ :attribute => "value" })
           .and_call_original
-        # rubocop:enable Style/BracesAroundHashParameters
         expect(Appsignal::Extension).to receive(:log)
           .with("group", method[1], 0, "Log message", instance_of(Appsignal::Extension::Data))
 

data/spec/lib/appsignal/marker_spec.rb

@@ -41,8 +41,8 @@ describe Appsignal::Marker do
         run
         expect(output).to include \
           "Notifying AppSignal of deploy with: revision: 503ce0923ed177a3ce000005, user: batman",
-          "Something went wrong while trying to notify AppSignal: 500 at "\
-          "#{config[:endpoint]}/1/markers"
+          "Something went wrong while trying to notify AppSignal: 500 at " \
+            "#{config[:endpoint]}/1/markers"
         expect(output).to_not include \
           "AppSignal has been notified of this deploy!"
       end

data/spec/lib/appsignal/minutely_spec.rb

@@ -133,7 +133,7 @@ describe Appsignal::Minutely do
               "oh no initialize!"
           )
           # Start of the error backtrace as debug log
-          expect(log).to contains_log :debug, File.expand_path("../../../../", __FILE__)
+          expect(log).to contains_log :debug, File.expand_path("../../..", __dir__)
         end
       end
     end
@@ -166,7 +166,7 @@ describe Appsignal::Minutely do
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 'my_probe' probe")
         expect(log).to contains_log(:debug, "Gathering minutely metrics with 'broken_probe' probe")
         expect(log).to contains_log(:error, "Error in minutely probe 'broken_probe': oh no!")
-        gem_path = File.expand_path("../../../../", __FILE__) # Start of backtrace
+        gem_path = File.expand_path("../../..", __dir__) # Start of backtrace
         expect(log).to contains_log(:debug, gem_path)
       end
     end
@@ -191,7 +191,7 @@ describe Appsignal::Minutely do
         # Fetch old thread
         thread = Appsignal::Minutely.instance_variable_get(:@thread)
         Appsignal::Minutely.start
-        thread && thread.join # Wait for old thread to exit
+        thread&.join # Wait for old thread to exit
       end.to_not(change { alive_thread_counter.call })
     end
   end