appsignal 4.0.3-java → 4.0.5-java

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/body_wrapper.rb

@@ -57,6 +57,21 @@ module Appsignal
         @transaction.set_error(error)
         raise error
       end
+
+      # Return whether the wrapped body responds to the method if this class does not.
+      # Based on:
+      # https://github.com/rack/rack/blob/0ed580bbe3858ffe5d530adf1bdad9ef9c03407c/lib/rack/body_proxy.rb#L16-L24
+      def respond_to_missing?(method_name, include_all = false)
+        super || @body.respond_to?(method_name, include_all)
+      end
+
+      # Delegate missing methods to the wrapped body.
+      # Based on:
+      # https://github.com/rack/rack/blob/0ed580bbe3858ffe5d530adf1bdad9ef9c03407c/lib/rack/body_proxy.rb#L44-L61
+      def method_missing(method_name, *args, &block)
+        @body.__send__(method_name, *args, &block)
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
 
     # The standard Rack body wrapper which exposes "each" for iterating

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/transmitter.rb

@@ -9,7 +9,8 @@ require "json"
 module Appsignal
   # @api private
   class Transmitter
-    CONTENT_TYPE = "application/json; charset=UTF-8"
+    JSON_CONTENT_TYPE = "application/json; charset=UTF-8"
+    NDJSON_CONTENT_TYPE = "application/x-ndjson; charset=UTF-8"
 
     HTTP_ERRORS = [
       EOFError,
@@ -53,17 +54,39 @@ module Appsignal
       end
     end
 
-    def transmit(payload)
-      config.logger.debug "Transmitting payload to #{uri}"
-      http_client.request(http_post(payload))
+    def transmit(payload, format: :json)
+      Appsignal.internal_logger.debug "Transmitting payload to #{uri}"
+      http_client.request(http_post(payload, :format => format))
     end
 
     private
 
-    def http_post(payload)
+    def http_post(payload, format: :json)
       Net::HTTP::Post.new(uri.request_uri).tap do |request|
-        request["Content-Type"] = CONTENT_TYPE
-        request.body = Appsignal::Utils::JSON.generate(payload)
+        request["Content-Type"] = content_type_for(format)
+        request.body = generate_body_for(format, payload)
+      end
+    end
+
+    def content_type_for(format)
+      case format
+      when :json
+        JSON_CONTENT_TYPE
+      when :ndjson
+        NDJSON_CONTENT_TYPE
+      else
+        raise ArgumentError, "Unknown Content-Type header for format: #{format}"
+      end
+    end
+
+    def generate_body_for(format, payload)
+      case format
+      when :json
+        Appsignal::Utils::JSON.generate(payload)
+      when :ndjson
+        Appsignal::Utils::NDJSON.generate(payload)
+      else
+        raise ArgumentError, "Unknown body generator for format: #{format}"
       end
     end
 

data/lib/appsignal/utils/ndjson.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Utils
+    class NDJSON
+      class << self
+        def generate(body)
+          body.map do |element|
+            Appsignal::Utils::JSON.generate(element)
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/utils.rb

@@ -12,4 +12,5 @@ require "appsignal/utils/data"
 require "appsignal/utils/hash_sanitizer"
 require "appsignal/utils/integration_logger"
 require "appsignal/utils/json"
+require "appsignal/utils/ndjson"
 require "appsignal/utils/query_params_sanitizer"

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -164,6 +164,7 @@ module Appsignal
       end
       Appsignal::Extension.stop
       Appsignal::Probes.stop
+      Appsignal::CheckIn.stop
     end
 
     # Configure the AppSignal Ruby gem using a DSL.

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

@@ -0,0 +1,202 @@
+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 }
+
+  before do
+    start_agent(
+      :options => appsignal_options,
+      :internal_logger => test_logger(log_stream)
+    )
+    allow(Appsignal::CheckIn).to receive(:scheduler).and_return(scheduler)
+    allow(Appsignal::CheckIn).to receive(:transmitter).and_return(transmitter)
+  end
+  after { stop_scheduler }
+
+  def stop_scheduler
+    scheduler.stop
+  end
+
+  describe "when Appsignal is not active" do
+    let(:appsignal_options) { { :active => false } }
+
+    it "does not transmit any events" do
+      expect(Appsignal).to_not be_started
+
+      cron_checkin.start
+      cron_checkin.finish
+      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 "does not transmit any events" do
+      Appsignal.stop
+
+      cron_checkin.start
+      cron_checkin.finish
+
+      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 "sends a cron check-in start" do
+      cron_checkin.start
+
+      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))
+
+      scheduler.stop
+
+      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(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))
+
+      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 "sends a cron check-in finish" do
+      cron_checkin.finish
+
+      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))
+
+      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 "logs an error if it fails" do
+      cron_checkin.finish
+
+      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))
+
+      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 "sends 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"
+        ))
+
+        output = Appsignal::CheckIn.cron("cron-checkin-with-block") { "output" }
+        expect(output).to eq("output")
+      end
+
+      it "does 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"
+        ))
+
+        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 "only sends 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"
+        ))
+
+        Appsignal::CheckIn.cron("cron-checkin-without-block")
+      end
+    end
+  end
+end