appsignal 4.0.4 → 4.0.6

data/lib/appsignal/rack/abstract_middleware.rb

@@ -19,7 +19,6 @@ module Appsignal
         @app = app
         @options = options
         @request_class = options.fetch(:request_class, ::Rack::Request)
-        @params_method = options.fetch(:params_method, :params)
         @instrument_event_name = options.fetch(:instrument_event_name, nil)
         @report_errors = options.fetch(:report_errors, DEFAULT_ERROR_REPORTING)
       end
@@ -136,52 +135,9 @@ module Appsignal
       # Override this method to set metadata after the app is called.
       # Call `super` to also include the default set metadata.
       def add_transaction_metadata_after(transaction, request)
-        transaction.set_metadata("path", request.path)
-
-        request_method = request_method_for(request)
-        transaction.set_metadata("method", request_method) if request_method
-
-        transaction.add_params { params_for(request) }
-        transaction.add_session_data { session_data_for(request) }
-        transaction.add_headers do
-          request.env if request.respond_to?(:env)
-        end
-
-        queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
-        transaction.set_queue_start(queue_start) if queue_start
-      end
-
-      def params_for(request)
-        return unless request.respond_to?(@params_method)
-
-        request.send(@params_method)
-      rescue => error
-        Appsignal.internal_logger.error(
-          "Exception while fetching params from '#{@request_class}##{@params_method}': " \
-            "#{error.class} #{error}"
-        )
-        nil
-      end
-
-      def request_method_for(request)
-        request.request_method
-      rescue => error
-        Appsignal.internal_logger.error(
-          "Exception while fetching the HTTP request method: #{error.class}: #{error}"
-        )
-        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
+        Appsignal::Rack::ApplyRackRequest
+          .new(request, @options)
+          .apply_to(transaction)
       end
 
       def request_for(env)

data/lib/appsignal/rack/event_handler.rb

@@ -79,6 +79,8 @@ module Appsignal
             #
             # The EventHandler.on_finish callback should be called first, this is
             # just a fallback if that doesn't get called.
+            #
+            # One such scenario is when a Puma "lowlevel_error" occurs.
             Appsignal::Transaction.complete_current!
           end
           transaction.start_event

data/lib/appsignal/rack/hanami_middleware.rb

@@ -5,13 +5,17 @@ module Appsignal
     # @api private
     class HanamiMiddleware < AbstractMiddleware
       def initialize(app, options = {})
-        options[:params_method] ||= :params
+        options[:params_method] = nil
         options[:instrument_event_name] ||= "process_action.hanami"
         super
       end
 
       private
 
+      def add_transaction_metadata_after(transaction, request)
+        transaction.add_params { params_for(request) }
+      end
+
       def params_for(request)
         ::Hanami::Action.params_class.new(request.env).to_h
       end

data/lib/appsignal/rack.rb

@@ -37,5 +37,73 @@ module Appsignal
         end
       end
     end
+
+    class ApplyRackRequest
+      attr_reader :request, :options
+
+      def initialize(request, options = {})
+        @request = request
+        @options = options
+        @params_method = options.fetch(:params_method, :params)
+      end
+
+      def apply_to(transaction)
+        request_path = request.path
+        transaction.set_metadata("request_path", request_path)
+        # TODO: Remove in next major/minor version
+        transaction.set_metadata("path", request_path)
+
+        request_method = request_method_for(request)
+        if request_method
+          transaction.set_metadata("request_method", request_method)
+          # TODO: Remove in next major/minor version
+          transaction.set_metadata("method", request_method)
+        end
+
+        transaction.add_params { params_for(request) }
+        transaction.add_session_data { session_data_for(request) }
+        transaction.add_headers do
+          request.env if request.respond_to?(:env)
+        end
+
+        queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
+        transaction.set_queue_start(queue_start) if queue_start
+      end
+
+      private
+
+      def params_for(request)
+        return if !@params_method || !request.respond_to?(@params_method)
+
+        request.send(@params_method)
+      rescue => error
+        Appsignal.internal_logger.error(
+          "Exception while fetching params from '#{request.class}##{@params_method}': " \
+            "#{error.class} #{error}"
+        )
+        nil
+      end
+
+      def request_method_for(request)
+        request.request_method
+      rescue => error
+        Appsignal.internal_logger.error(
+          "Exception while fetching the HTTP request method: #{error.class}: #{error}"
+        )
+        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
+    end
   end
 end

data/lib/appsignal/version.rb

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

data/spec/lib/appsignal/check_in/cron_spec.rb

@@ -1,193 +1,191 @@
 describe Appsignal::CheckIn::Cron do
+  let(:log_stream) { std_stream }
+  let(:logs) { log_contents(log_stream) }
+  let(:appsignal_options) { {} }
   let(:config) { project_fixture_config }
   let(:cron_checkin) { described_class.new(:identifier => "cron-checkin-name") }
-  let(:transmitter) { Appsignal::Transmitter.new("https://checkin-endpoint.invalid") }
-  let(:scheduler) { Appsignal::CheckIn::Scheduler.new }
+  let(:scheduler) { Appsignal::CheckIn.scheduler }
 
   before do
-    allow(Appsignal).to receive(:active?).and_return(true)
-    config.logger = Logger.new(StringIO.new)
-    allow(Appsignal::CheckIn).to receive(:scheduler).and_return(scheduler)
-    allow(Appsignal::CheckIn).to receive(:transmitter).and_return(transmitter)
+    start_agent(
+      :options => appsignal_options,
+      :internal_logger => test_logger(log_stream)
+    )
   end
+  after { stop_scheduler }
 
-  after do
+  def stop_scheduler
     scheduler.stop
   end
 
   describe "when Appsignal is not active" do
-    it "should not transmit any events" do
-      allow(Appsignal).to receive(:active?).and_return(false)
+    let(:appsignal_options) { { :active => false } }
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` start event") &&
-        message.include?("AppSignal is not active")
-      end)
+    it "does not transmit any events" do
+      expect(Appsignal).to_not be_started
 
       cron_checkin.start
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` finish event") &&
-        message.include?("AppSignal is not active")
-      end)
-
       cron_checkin.finish
-
-      expect(transmitter).not_to receive(:transmit)
-
-      scheduler.stop
+      stop_scheduler
+
+      expect(logs).to contains_log(
+        :debug,
+        /Cannot transmit cron check-in `cron-checkin-name` start event .+: AppSignal is not active/
+      )
+      expect(logs).to contains_log(
+        :debug,
+        /Cannot transmit cron check-in `cron-checkin-name` finish event .+: AppSignal is not active/
+      )
     end
   end
 
   describe "when AppSignal is stopped" do
-    it "should not transmit any events" do
-      expect(transmitter).not_to receive(:transmit)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
-
+    it "does not transmit any events" do
       Appsignal.stop
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` start event") &&
-        message.include?("AppSignal is stopped")
-      end)
-
       cron_checkin.start
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Cannot transmit cron check-in `cron-checkin-name` finish event") &&
-        message.include?("AppSignal is stopped")
-      end)
-
       cron_checkin.finish
 
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
-
-      Appsignal.stop
+      expect(logs).to contains_log(
+        :debug,
+        "Cannot transmit cron check-in `cron-checkin-name` start event"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Cannot transmit cron check-in `cron-checkin-name` finish event"
+      )
     end
   end
 
   describe "#start" do
-    it "should send a cron check-in start" do
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` start event")
-      end)
-
+    it "sends a cron check-in start" do
       cron_checkin.start
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `cron-checkin-name` start event")
-      end)
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "start",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "200", nil))
+      stub_check_in_request(
+        :events => [
+          "identifier" => "cron-checkin-name",
+          "kind" => "start",
+          "check_in_type" => "cron"
+        ]
+      )
 
       scheduler.stop
-    end
 
-    it "should log an error if it fails" do
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` start event")
-      end)
+      expect(logs).to_not contains_log(:error)
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` start event"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `cron-checkin-name` start event"
+      )
+    end
 
+    it "logs an error if it fails" do
       cron_checkin.start
 
-      expect(Appsignal.internal_logger).to receive(:error).with(satisfy do |message|
-        message.include?("Failed to transmit cron check-in `cron-checkin-name` start event") &&
-          message.include?("499 status code")
-      end)
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "start",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "499", nil))
+      stub_check_in_request(
+        :events => [
+          "identifier" => "cron-checkin-name",
+          "kind" => "start",
+          "check_in_type" => "cron"
+        ],
+        :response => { :status => 499 }
+      )
 
       scheduler.stop
+
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` start event"
+      )
+      expect(logs).to contains_log(
+        :error,
+        /Failed to transmit cron check-in `cron-checkin-name` start event .+: 499 status code/
+      )
     end
   end
 
   describe "#finish" do
-    it "should send a cron check-in finish" do
-      expect(Appsignal.internal_logger).not_to receive(:error)
-
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` finish event")
-      end)
-
+    it "sends a cron check-in finish" do
       cron_checkin.finish
 
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Transmitted cron check-in `cron-checkin-name` finish event")
-      end)
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "finish",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "200", nil))
+      stub_check_in_request(
+        :events => [
+          "identifier" => "cron-checkin-name",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ]
+      )
 
       scheduler.stop
+      expect(logs).to_not contains_log(:error)
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` finish event"
+      )
+      expect(logs).to contains_log(
+        :debug,
+        "Transmitted cron check-in `cron-checkin-name` finish event"
+      )
     end
 
-    it "should log an error if it fails" do
-      expect(Appsignal.internal_logger).to receive(:debug).with(satisfy do |message|
-        message.include?("Scheduling cron check-in `cron-checkin-name` finish event")
-      end)
-
+    it "logs an error if it fails" do
       cron_checkin.finish
 
-      expect(Appsignal.internal_logger).to receive(:error).with(satisfy do |message|
-        message.include?("Failed to transmit cron check-in `cron-checkin-name` finish event") &&
-          message.include?("499 status code")
-      end)
-
-      expect(transmitter).to receive(:transmit).with([hash_including(
-        :identifier => "cron-checkin-name",
-        :kind => "finish",
-        :check_in_type => "cron"
-      )], :format => :ndjson).and_return(Net::HTTPResponse.new(nil, "499", nil))
+      stub_check_in_request(
+        :events => [
+          "identifier" => "cron-checkin-name",
+          "kind" => "finish",
+          "check_in_type" => "cron"
+        ],
+        :response => { :status => 499 }
+      )
 
       scheduler.stop
+
+      expect(logs).to contains_log(
+        :debug,
+        "Scheduling cron check-in `cron-checkin-name` finish event"
+      )
+      expect(logs).to contains_log(
+        :error,
+        /Failed to transmit cron check-in `cron-checkin-name` finish event .+: 499 status code/
+      )
     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(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "start",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
-
-        expect(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
+      it "sends a cron check-in start and finish and return the block output" do
+        stub_check_in_request(
+          :events => [
+            "identifier" => "cron-checkin-with-block",
+            "kind" => "start",
+            "check_in_type" => "cron"
+          ]
+        )
+        stub_check_in_request(
+          :events => [
+            "identifier" => "cron-checkin-with-block",
+            "kind" => "finish",
+            "check_in_type" => "cron"
+          ]
+        )
 
         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(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "start",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
-
-        expect(scheduler).not_to receive(:schedule).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-with-block",
-          :check_in_type => "cron"
-        ))
+      it "does not send a cron check-in finish event when an error is raised" do
+        stub_check_in_request(
+          :events => [
+            "identifier" => "cron-checkin-with-block",
+            "kind" => "start",
+            "check_in_type" => "cron"
+          ]
+        )
 
         expect do
           Appsignal::CheckIn.cron("cron-checkin-with-block") { raise "error" }
@@ -196,12 +194,14 @@ describe Appsignal::CheckIn::Cron do
     end
 
     describe "when no block is given" do
-      it "should only send a cron check-in finish event" do
-        expect(scheduler).to receive(:schedule).with(hash_including(
-          :kind => "finish",
-          :identifier => "cron-checkin-without-block",
-          :check_in_type => "cron"
-        ))
+      it "only sends a cron check-in finish event" do
+        stub_check_in_request(
+          :events => [
+            "identifier" => "cron-checkin-without-block",
+            "kind" => "finish",
+            "check_in_type" => "cron"
+          ]
+        )
 
         Appsignal::CheckIn.cron("cron-checkin-without-block")
       end