appsignal 4.0.2-java → 4.0.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a43d932132633873f343b1a180772e9949115f85fcce3d9e13d9af6a23eb824
-  data.tar.gz: 2d3d8fa4dfe45a3a42c89955bd243cd2c7871b3f2ac2978e7bef8333b6518b5e
+  metadata.gz: 4d56061a26addb877656ebb516f8cdd174feb64651cee8816f67e9eaa1ac946f
+  data.tar.gz: c7d0582debd5c6d9ed29f2239a4baeed92ebdad46606c423e7537495b4dea3ab
 SHA512:
-  metadata.gz: a7f97a072db897dc6433d059067ad0bd0db054ec6d2b7a2f6c16ea9e8876e7b7f1b5ec3abdfba554fda60c6a211c8b3455a39221a9c7ebe8beb336a129fa0eec
-  data.tar.gz: 52e9a83f45fe345d895453e38833047c305f0b474918d8510148959a87a8e1ae797773213082152a03a19f8fd9cd7adfc37b5b0b6c33572f97fd9fdf3d67b5e1
+  metadata.gz: f6710e1277f99b861d0c1981e300c21203c8ef91c3c49b23d39453b3970872e968f1eac140b9561684f1b569b7ab09406d352f06d37d852fa7c985ed858eb5d2
+  data.tar.gz: c0bf6a6ba6454fee105c6890db3154e03c0ad64c6b5ab325fb0186edf99066e923d7b6b4043ea4d77428155fbc58371ece1309517109437edc8cc265ffda554a

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # 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._
+
+### Changed
+
+- Do not report Sidekiq `Sidekiq::JobRetry::Handled` and `Sidekiq::JobRetry::Skip` errors. These errors would be reported by our Rails error subscriber. These are an internal Sidekiq errors we do not need to report. (patch [e385ee2c](https://github.com/appsignal/appsignal-ruby/commit/e385ee2c4da13063e6f1a7a207286dda74113fc4))
+
+### Removed
+
+- Remove the `app_path` writer in the `Appsignal.configure` helper. This was deprecated in version 3.x. It is removed now in the next major version.
+
+  Use the `root_path` keyword argument in the `Appsignal.configure` helper (`Appsignal.configure(:root_path => "...")`) to change the AppSignal root path if necessary.
+
+  (patch [6335da6d](https://github.com/appsignal/appsignal-ruby/commit/6335da6d99a5ba7687fb5885eee27b9633d80474))
+
 ## 4.0.2
 
 _Published on 2024-08-23._

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

@@ -225,7 +225,7 @@ module Appsignal
     #   How to integrate AppSignal manually
     def initialize(
       root_path,
-      initial_env,
+      env,
       logger = Appsignal.internal_logger
     )
       @root_path = root_path
@@ -234,8 +234,7 @@ module Appsignal
       @logger = logger
       @valid = false
 
-      @initial_env = initial_env
-      @env = initial_env.to_s
+      @env = env.to_s
       @config_hash = {}
       @system_config = {}
       @loaders_config = {}
@@ -270,7 +269,7 @@ module Appsignal
       end
 
       # Track origin of env
-      @initial_config[:env] = @initial_env.to_s
+      @initial_config[:env] = @env
 
       # Load the config file if it exists
       @file_config = load_from_disk || {}
@@ -560,14 +559,6 @@ module Appsignal
         @config.root_path
       end
 
-      def app_path=(_path)
-        Appsignal::Utils::StdoutAndLoggerMessage.warning \
-          "The `Appsignal.configure`'s `app_path=` writer is deprecated " \
-            "and can no longer be used to set the root path. " \
-            "Use the `Appsignal.configure`'s method `root_path` keyword argument " \
-            "to set the root path."
-      end
-
       def env
         @config.env
       end

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/integrations/railtie.rb

@@ -102,14 +102,9 @@ 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)
+          # We don't need to alert about Sidekiq job internal errors.
+          defined?(Sidekiq::JobRetry::Handled) && error.is_a?(Sidekiq::JobRetry::Handled)
         end
 
         def context_for(context)

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.2"
+  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.