appsignal 4.0.3 → 4.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41324be9bb4bd42bfcee997c778b0ae1eb0a1a773e044503eab2466779f3bcb7
-  data.tar.gz: 1ab95f249d94eedba7e86e36d3f74d217bd57deed236e6b352b190dc34007eb5
+  metadata.gz: 91e5aad04da2524d3d2f4bd983ecd76cf1a33380a1bc2a6bf8aab1bd4d91db5b
+  data.tar.gz: c7d0582debd5c6d9ed29f2239a4baeed92ebdad46606c423e7537495b4dea3ab
 SHA512:
-  metadata.gz: f8e8e89b583dc585b83fcfc70378f5090e0854d7c19b2f375a68739fc1325bcd184d8ab678fdb68af55e32d81d60ecbb764d3768f0d2c02ea6d1a974b808018c
-  data.tar.gz: d25b331756ceafe336d5b430577fb98da0696f5f92613a47d89f30007b910a4057cf981ddb1d841d295cfdb31f48d69bb8fecb1e7071d933dba47b1160d701bf
+  metadata.gz: a482b32ffa5d9ddc805a65507ab4d526f9c299969c86123743e8f0c4830af6f8abd3eecd805cb7c4eec6abcd474a2f97704ac9f5129825b7958245cc973ff6db
+  data.tar.gz: c0bf6a6ba6454fee105c6890db3154e03c0ad64c6b5ab325fb0186edf99066e923d7b6b4043ea4d77428155fbc58371ece1309517109437edc8cc265ffda554a

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # AppSignal for Ruby gem Changelog
 
+## 4.0.4
+
+_Published on 2024-08-29._
+
+### Changed
+
+- Send check-ins concurrently. When calling `Appsignal::CheckIn.cron`, instead of blocking the current thread while the check-in events are sent, schedule them to be sent in a separate thread.
+
+  When shutting down your application manually, call `Appsignal.stop` to block until all scheduled check-ins have been sent.
+
+  (patch [46d4ca74](https://github.com/appsignal/appsignal-ruby/commit/46d4ca74f4c188cc011653ed23969ad7ec770812))
+
+### Fixed
+
+- Make our Rack BodyWrapper behave like a Rack BodyProxy. If a method doesn't exist on our BodyWrapper class, but it does exist on the body, behave like the Rack BodyProxy and call the method on the wrapped body. (patch [e2376305](https://github.com/appsignal/appsignal-ruby/commit/e23763058a3fb980f1054e9c1eaf7e0f25f75666))
+- Do not report `SignalException` errors from our `at_exit` error reporter. (patch [3ba3ce31](https://github.com/appsignal/appsignal-ruby/commit/3ba3ce31ee3f3e84665c9f2f18d488c689cff6c2))
+
 ## 4.0.3
 
 _Published on 2024-08-26._

data/lib/appsignal/check_in/cron.rb

@@ -3,15 +3,6 @@
 module Appsignal
   module CheckIn
     class Cron
-      class << self
-        # @api private
-        def transmitter
-          @transmitter ||= Appsignal::Transmitter.new(
-            "#{Appsignal.config[:logging_endpoint]}/check_ins/json"
-          )
-        end
-      end
-
       # @api private
       attr_reader :identifier, :digest
 
@@ -21,11 +12,11 @@ module Appsignal
       end
 
       def start
-        transmit_event("start")
+        CheckIn.scheduler.schedule(event("start"))
       end
 
       def finish
-        transmit_event("finish")
+        CheckIn.scheduler.schedule(event("finish"))
       end
 
       private
@@ -39,29 +30,6 @@ module Appsignal
           :check_in_type => "cron"
         }
       end
-
-      def transmit_event(kind)
-        unless Appsignal.active?
-          Appsignal.internal_logger.debug(
-            "AppSignal not active, not transmitting cron check-in event"
-          )
-          return
-        end
-
-        response = self.class.transmitter.transmit(event(kind))
-
-        if response.code.to_i >= 200 && response.code.to_i < 300
-          Appsignal.internal_logger.debug(
-            "Transmitted cron check-in `#{identifier}` (#{digest}) #{kind} event"
-          )
-        else
-          Appsignal.internal_logger.error(
-            "Failed to transmit cron check-in #{kind} event: status code was #{response.code}"
-          )
-        end
-      rescue => e
-        Appsignal.internal_logger.error("Failed to transmit cron check-in #{kind} event: #{e}")
-      end
     end
   end
 end

data/lib/appsignal/check_in/scheduler.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module CheckIn
+    class Scheduler
+      INITIAL_DEBOUNCE_SECONDS = 0.1
+      BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS = 10
+
+      def initialize
+        # The mutex is used to synchronize access to the events array, the
+        # waker thread and the main thread, as well as queue writes
+        # (which depend on the events array) and closes (so they do not
+        # happen at the same time that an event is added to the scheduler)
+        @mutex = Mutex.new
+        # The transmitter thread will be started when an event is first added.
+        @thread = nil
+        @queue = Thread::Queue.new
+        # Scheduled events that have not been sent to the transmitter thread
+        # yet. A copy of this array is pushed to the queue by the waker thread
+        # after it has awaited the debounce period.
+        @events = []
+        # The waker thread is used to schedule debounces. It will be started
+        # when an event is first added.
+        @waker = nil
+        # For internal testing purposes.
+        @transmitted = 0
+      end
+
+      def schedule(event)
+        unless Appsignal.active?
+          Appsignal.internal_logger.debug(
+            "Cannot transmit #{describe([event])}: AppSignal is not active"
+          )
+          return
+        end
+
+        @mutex.synchronize do
+          if @queue.closed?
+            Appsignal.internal_logger.debug(
+              "Cannot transmit #{describe([event])}: AppSignal is stopped"
+            )
+            return
+          end
+          add_event(event)
+          # If we're not already waiting to be awakened from a scheduled
+          # debounce, schedule a short debounce, which will push the events
+          # to the queue and schedule a long debounce.
+          start_waker(INITIAL_DEBOUNCE_SECONDS) if @waker.nil?
+
+          Appsignal.internal_logger.debug(
+            "Scheduling #{describe([event])} to be transmitted"
+          )
+
+          # Make sure to start the thread after an event has been added.
+          @thread ||= Thread.new(&method(:run))
+        end
+      end
+
+      def stop
+        @mutex.synchronize do
+          # Flush all events before closing the queue.
+          push_events
+        rescue ClosedQueueError
+          # The queue is already closed (by a previous call to `#stop`)
+          # so it is not possible to push events to it anymore.
+        ensure
+          # Ensure calling `#stop` closes the queue and kills
+          # the waker thread, disallowing any further events from being
+          # scheduled with `#schedule`.
+          stop_waker
+          @queue.close
+
+          # Block until the thread has finished.
+          @thread&.join
+        end
+      end
+
+      # @api private
+      # For internal testing purposes.
+      attr_reader :thread, :waker, :queue, :events, :transmitted
+
+      private
+
+      def run
+        loop do
+          events = @queue.pop
+          break if events.nil?
+
+          transmit(events)
+          @transmitted += 1
+        end
+      end
+
+      def transmit(events)
+        description = describe(events)
+
+        begin
+          response = CheckIn.transmitter.transmit(events, :format => :ndjson)
+
+          if (200...300).include?(response.code.to_i)
+            Appsignal.internal_logger.debug(
+              "Transmitted #{description}"
+            )
+          else
+            Appsignal.internal_logger.error(
+              "Failed to transmit #{description}: #{response.code} status code"
+            )
+          end
+        rescue => e
+          Appsignal.internal_logger.error("Failed to transmit #{description}: #{e.message}")
+        end
+      end
+
+      def describe(events)
+        if events.empty?
+          # This shouldn't happen.
+          "no check-in events"
+        elsif events.length > 1
+          "#{events.length} check-in events"
+        else
+          event = events.first
+          if event[:check_in_type] == "cron"
+            "cron check-in `#{event[:identifier] || "unknown"}` " \
+              "#{event[:kind] || "unknown"} event (digest #{event[:digest] || "unknown"})" \
+          else
+            "unknown check-in event"
+          end
+        end
+      end
+
+      # Must be called from within a `@mutex.synchronize` block.
+      def add_event(event)
+        # Remove redundant events, keeping the newly added one, which
+        # should be the one with the most recent timestamp.
+        if event[:check_in_type] == "cron"
+          # Remove any existing cron check-in event with the same identifier,
+          # digest and kind as the one we're adding.
+          @events.reject! do |existing_event|
+            next unless existing_event[:identifier] == event[:identifier] &&
+              existing_event[:digest] == event[:digest] &&
+              existing_event[:kind] == event[:kind] &&
+              existing_event[:check_in_type] == "cron"
+
+            Appsignal.internal_logger.debug(
+              "Replacing previously scheduled #{describe([existing_event])}"
+            )
+
+            true
+          end
+        end
+
+        @events << event
+      end
+
+      # Must be called from within a `@mutex.synchronize` block.
+      def start_waker(debounce)
+        stop_waker
+
+        @waker = Thread.new do
+          sleep(debounce)
+
+          @mutex.synchronize do
+            # Make sure this waker doesn't get killed, so it can push
+            # events and schedule a new waker.
+            @waker = nil
+            push_events
+          end
+        end
+      end
+
+      # Must be called from within a `@mutex.synchronize` block.
+      def stop_waker
+        @waker&.kill
+        @waker&.join
+        @waker = nil
+      end
+
+      # Must be called from within a `@mutex.synchronize` block.
+      def push_events
+        return if @events.empty?
+
+        # Push a copy of the events to the queue, and clear the events array.
+        # This ensures that `@events` always contains events that have not
+        # yet been pushed to the queue.
+        @queue.push(@events.dup)
+        @events.clear
+
+        start_waker(BETWEEN_TRANSMISSIONS_DEBOUNCE_SECONDS)
+      end
+    end
+  end
+end

data/lib/appsignal/check_in.rb

@@ -39,8 +39,26 @@ module Appsignal
         cron.finish
         output
       end
+
+      # @api private
+      def transmitter
+        @transmitter ||= Transmitter.new(
+          "#{Appsignal.config[:logging_endpoint]}/check_ins/json"
+        )
+      end
+
+      # @api private
+      def scheduler
+        @scheduler ||= Scheduler.new
+      end
+
+      # @api private
+      def stop
+        scheduler&.stop
+      end
     end
   end
 end
 
+require "appsignal/check_in/scheduler"
 require "appsignal/check_in/cron"

data/lib/appsignal/cli/diagnose.rb

@@ -150,7 +150,7 @@ module Appsignal
             ENV.fetch("APPSIGNAL_DIAGNOSE_ENDPOINT", DIAGNOSE_ENDPOINT),
             Appsignal.config
           )
-          response = transmitter.transmit(:diagnose => data)
+          response = transmitter.transmit({ :diagnose => data })
 
           unless response.code == "200"
             puts "  Error: Something went wrong while submitting the report " \

data/lib/appsignal/hooks/at_exit.rb

@@ -35,7 +35,8 @@ module Appsignal
 
         IGNORED_ERRORS = [
           # Normal exits from the application we do not need to report
-          SystemExit
+          SystemExit,
+          SignalException
         ].freeze
 
         def self.ignored_error?(error)

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/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.4"
 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,210 @@
+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("https://checkin-endpoint.invalid") }
+  let(:scheduler) { Appsignal::CheckIn::Scheduler.new }
+
+  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)
+  end
+
+  after do
+    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)
+
+      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)
+
+      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
+    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")
+
+      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
+    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)
+
+      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))
+
+      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)
+
+      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))
+
+      scheduler.stop
+    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)
+
+      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))
+
+      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` finish event")
+      end)
+
+      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))
+
+      scheduler.stop
+    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"
+        ))
+
+        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"
+        ))
+
+        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(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