appsignal 3.9.1-java → 3.9.3-java

data/lib/appsignal/integrations/padrino.rb

@@ -12,63 +12,66 @@ module Appsignal
         root = Padrino.mounted_root
         Appsignal.config = Appsignal::Config.new(root, Padrino.env)
 
-        Appsignal.start_logger
         Appsignal.start
       end
     end
   end
 end
 
-module Appsignal::Integrations::PadrinoIntegration
-  def route!(base = settings, pass_block = nil)
-    return super if !Appsignal.active? || env["sinatra.static_file"]
+module Appsignal
+  module Integrations
+    module PadrinoIntegration
+      def route!(base = settings, pass_block = nil)
+        return super if !Appsignal.active? || env["sinatra.static_file"]
 
-    transaction = Appsignal::Transaction.create(
-      SecureRandom.uuid,
-      Appsignal::Transaction::HTTP_REQUEST,
-      request
-    )
-    begin
-      Appsignal.instrument("process_action.padrino") do
-        super
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request
+        )
+        begin
+          Appsignal.instrument("process_action.padrino") do
+            super
+          end
+        rescue Exception => error # rubocop:disable Lint/RescueException
+          transaction.set_error(error)
+          raise error
+        ensure
+          transaction.set_action_if_nil(get_payload_action(request))
+          transaction.set_metadata("path", request.path)
+          transaction.set_metadata("method", request.request_method)
+          transaction.set_http_or_background_queue_start
+          Appsignal::Transaction.complete_current!
+        end
       end
-    rescue Exception => error # rubocop:disable Lint/RescueException
-      transaction.set_error(error)
-      raise error
-    ensure
-      transaction.set_action_if_nil(get_payload_action(request))
-      transaction.set_metadata("path", request.path)
-      transaction.set_metadata("method", request.request_method)
-      transaction.set_http_or_background_queue_start
-      Appsignal::Transaction.complete_current!
-    end
-  end
 
-  private
+      private
 
-  def get_payload_action(request)
-    # Short-circut is there's no request object to obtain information from
-    return settings.name.to_s unless request
+      def get_payload_action(request)
+        # Short-circut is there's no request object to obtain information from
+        return settings.name.to_s unless request
 
-    # Newer versions expose the action / controller on the request class.
-    # Newer versions also still expose a route_obj so we must prioritize the
-    # action/fullpath methods.
-    # The `request.action` and `request.controller` values are `nil` when a
-    # endpoint is not found, `""` if not specified by the user.
-    controller_name = request.controller if request.respond_to?(:controller)
-    action_name = request.action if request.respond_to?(:action)
-    action_name ||= ""
+        # Newer versions expose the action / controller on the request class.
+        # Newer versions also still expose a route_obj so we must prioritize the
+        # action/fullpath methods.
+        # The `request.action` and `request.controller` values are `nil` when a
+        # endpoint is not found, `""` if not specified by the user.
+        controller_name = request.controller if request.respond_to?(:controller)
+        action_name = request.action if request.respond_to?(:action)
+        action_name ||= ""
 
-    return "#{settings.name}:#{controller_name}##{action_name}" unless action_name.empty?
+        return "#{settings.name}:#{controller_name}##{action_name}" unless action_name.empty?
 
-    # Older versions of Padrino work with a route object
-    if request.respond_to?(:route_obj) && request.route_obj
-      return "#{settings.name}:#{request.route_obj.original_path}"
-    end
+        # Older versions of Padrino work with a route object
+        if request.respond_to?(:route_obj) && request.route_obj
+          return "#{settings.name}:#{request.route_obj.original_path}"
+        end
 
-    # Fall back to the application name if we haven't found an action name in
-    # any previous methods.
-    "#{settings.name}#unknown"
+        # Fall back to the application name if we haven't found an action name in
+        # any previous methods.
+        "#{settings.name}#unknown"
+      end
+    end
   end
 end
 

data/lib/appsignal/integrations/railtie.rb

@@ -26,9 +26,6 @@ module Appsignal
           :log_path => Rails.root.join("log")
         )
 
-        # Start logger
-        Appsignal.start_logger
-
         app.middleware.insert(
           0,
           ::Rack::Events,
@@ -71,7 +68,7 @@ module Appsignal
             transaction.set_action(action_name) if action_name
             transaction.set_metadata("path", path)
             transaction.set_metadata("method", method)
-            transaction.params = params
+            transaction.set_params_if_nil(params)
             transaction.set_sample_data("custom_data", custom_data) if custom_data
 
             tags[:severity] = severity

data/lib/appsignal/integrations/resque.rb

@@ -25,7 +25,7 @@ module Appsignal
               ResqueHelpers.arguments(payload),
               Appsignal.config[:filter_parameters]
             )
-          transaction.params = args if args
+          transaction.set_params_if_nil(args)
           transaction.set_tags("queue" => queue)
 
           Appsignal::Transaction.complete_current!

data/lib/appsignal/integrations/sidekiq.rb

@@ -45,7 +45,7 @@ module Appsignal
             )
           transaction.set_action_if_nil("SidekiqInternal")
           transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
-          transaction.params = { :jobstr => sidekiq_context[:jobstr] }
+          transaction.set_params_if_nil(:jobstr => sidekiq_context[:jobstr])
           transaction.set_error(exception)
         end
 
@@ -83,9 +83,7 @@ module Appsignal
         raise exception
       ensure
         if transaction
-          params = filtered_arguments(item)
-          transaction.params = params if params
-
+          transaction.set_params_if_nil(filtered_arguments(item))
           transaction.set_http_or_background_queue_start
           Appsignal::Transaction.complete_current! unless exception
 

data/lib/appsignal/integrations/sinatra.rb

@@ -12,8 +12,13 @@ unless Appsignal.active?
     app_settings.environment
   )
 
-  Appsignal.start_logger
   Appsignal.start
 end
 
-::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation) if Appsignal.active?
+if Appsignal.active?
+  ::Sinatra::Base.use(
+    ::Rack::Events,
+    [Appsignal::Rack::EventHandler.new]
+  )
+  ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
+end

data/lib/appsignal/probes/gvl.rb

@@ -25,6 +25,11 @@ module Appsignal
         Appsignal.internal_logger.debug("Initializing GVL probe")
         @appsignal = appsignal
         @gvl_tools = gvl_tools
+
+        # Store the process name and ID at initialization time
+        # to avoid picking up changes to the process name at runtime
+        @process_name = File.basename($PROGRAM_NAME).split.first || "[unknown process]"
+        @process_id = Process.pid
       end
 
       def call
@@ -39,13 +44,30 @@ module Appsignal
         gauge_delta :gvl_global_timer, monotonic_time_ns do |time_delta_ns|
           if time_delta_ns > 0
             time_delta_ms = time_delta_ns / 1_000_000
-            set_gauge_with_hostname("gvl_global_timer", time_delta_ms)
+            set_gauges_with_hostname_and_process(
+              "gvl_global_timer",
+              time_delta_ms
+            )
           end
         end
       end
 
       def probe_waiting_threads
-        set_gauge_with_hostname("gvl_waiting_threads", @gvl_tools::WaitingThreads.count)
+        set_gauges_with_hostname_and_process(
+          "gvl_waiting_threads",
+          @gvl_tools::WaitingThreads.count
+        )
+      end
+
+      def set_gauges_with_hostname_and_process(name, value)
+        set_gauge_with_hostname(name, value, {
+          :process_name => @process_name,
+          :process_id => @process_id
+        })
+
+        # Also set the gauge without the process name and ID for
+        # compatibility with existing automated dashboards
+        set_gauge_with_hostname(name, value)
       end
     end
   end

data/lib/appsignal/probes/sidekiq.rb

@@ -47,7 +47,7 @@ module Appsignal
       # @api private
       def self.dependencies_present?
         return true if sidekiq7_and_greater?
-        return unless defined?(::Redis::VERSION) # Sidekiq <= 6
+        return false unless defined?(::Redis::VERSION) # Sidekiq <= 6
 
         Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
       end

data/lib/appsignal/probes.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Appsignal
-  module Probes # rubocop:disable Metrics/ModuleLength
+  module Probes
     ITERATION_IN_SECONDS = 60
 
     class ProbeCollection

data/lib/appsignal/rack/abstract_middleware.rb

@@ -3,9 +3,11 @@
 require "rack"
 
 module Appsignal
-  # @api private
   module Rack
+    # @api private
     class AbstractMiddleware
+      DEFAULT_ERROR_REPORTING = :default
+
       def initialize(app, options = {})
         Appsignal.internal_logger.debug "Initializing #{self.class}"
         @app = app
@@ -13,6 +15,7 @@ module Appsignal
         @request_class = options.fetch(:request_class, ::Rack::Request)
         @params_method = options.fetch(:params_method, :params)
         @instrument_span_name = options.fetch(:instrument_span_name, "process.abstract")
+        @report_errors = options.fetch(:report_errors, DEFAULT_ERROR_REPORTING)
       end
 
       def call(env)
@@ -32,15 +35,31 @@ module Appsignal
               )
             end
 
-          add_transaction_metadata_before(transaction, request)
-          if wrapped_instrumentation
-            instrument_wrapped_request(request, transaction)
-          else
+          unless wrapped_instrumentation
             # Set transaction on the request environment so other nested
             # middleware can detect if there is parent instrumentation
             # middleware active.
             env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
-            instrument_request(request, transaction)
+          end
+
+          begin
+            add_transaction_metadata_before(transaction, request)
+            # Report errors if the :report_errors option is set to true or when
+            # there is no parent instrumentation that can rescue and report the error.
+            if @report_errors || !wrapped_instrumentation
+              instrument_app_call_with_exception_handling(
+                request.env,
+                transaction,
+                wrapped_instrumentation
+              )
+            else
+              instrument_app_call(request.env)
+            end
+          ensure
+            add_transaction_metadata_after(transaction, request)
+
+            # Complete transaction because this is the top instrumentation middleware.
+            Appsignal::Transaction.complete_current! unless wrapped_instrumentation
           end
         else
           @app.call(env)
@@ -56,35 +75,40 @@ module Appsignal
       # Either another {GenericInstrumentation} or {EventHandler} is higher in
       # the stack and will report the exception and complete the transaction.
       #
-      # @see {#instrument_request}
-      def instrument_wrapped_request(request, transaction)
-        instrument_app_call(request.env)
-      ensure
-        add_transaction_metadata_after(transaction, request)
+      # @see {#instrument_app_call_with_exception_handling}
+      def instrument_app_call(env)
+        if @instrument_span_name
+          Appsignal.instrument(@instrument_span_name) do
+            @app.call(env)
+          end
+        else
+          @app.call(env)
+        end
       end
 
       # Instrument the request fully. This is used by the top instrumentation
       # middleware in the middleware stack. Unlike
-      # {#instrument_wrapped_request} this will report any exceptions being
+      # {#instrument_app_call} this will report any exceptions being
       # raised.
       #
-      # @see {#instrument_wrapped_request}
-      def instrument_request(request, transaction)
-        instrument_app_call(request.env)
+      # @see {#instrument_app_call}
+      def instrument_app_call_with_exception_handling(env, transaction, wrapped_instrumentation)
+        instrument_app_call(env)
       rescue Exception => error # rubocop:disable Lint/RescueException
-        transaction.set_error(error)
+        report_errors =
+          if @report_errors == DEFAULT_ERROR_REPORTING
+            # If there's no parent transaction, report the error
+            !wrapped_instrumentation
+          elsif @report_errors.respond_to?(:call)
+            # If the @report_errors option is callable, call it with the
+            # request environment so it can determine if the error needs to be
+            # reported.
+            @report_errors.call(env)
+          else
+            @report_errors
+          end
+        transaction.set_error(error) if report_errors
         raise error
-      ensure
-        add_transaction_metadata_after(transaction, request)
-
-        # Complete transaction because this is the top instrumentation middleware.
-        Appsignal::Transaction.complete_current!
-      end
-
-      def instrument_app_call(env)
-        Appsignal.instrument(@instrument_span_name) do
-          @app.call(env)
-        end
       end
 
       # Add metadata to the transaction based on the request environment.
@@ -101,7 +125,10 @@ module Appsignal
           request.env["appsignal.route"] || request.env["appsignal.action"]
         transaction.set_action_if_nil(default_action)
         transaction.set_metadata("path", request.path)
-        transaction.set_metadata("method", request.request_method)
+
+        request_method = request_method_for(request)
+        transaction.set_metadata("method", request_method) if request_method
+
         transaction.set_params_if_nil(params_for(request))
         transaction.set_http_or_background_queue_start
       end
@@ -118,6 +145,13 @@ module Appsignal
         nil
       end
 
+      def request_method_for(request)
+        request.request_method
+      rescue => error
+        Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
+        nil
+      end
+
       def request_for(env)
         @request_class.new(env)
       end

data/lib/appsignal/rack/event_handler.rb

@@ -4,8 +4,10 @@ module Appsignal
   module Rack
     APPSIGNAL_TRANSACTION = "appsignal.transaction"
     APPSIGNAL_EVENT_HANDLER_ID = "appsignal.event_handler_id"
+    APPSIGNAL_EVENT_HANDLER_HAS_ERROR = "appsignal.event_handler.error"
     RACK_AFTER_REPLY = "rack.after_reply"
 
+    # @api private
     class EventHandler
       include ::Rack::Events::Abstract
 
@@ -42,22 +44,22 @@ module Appsignal
 
           request.env[RACK_AFTER_REPLY] ||= []
           request.env[RACK_AFTER_REPLY] << proc do
+            next unless event_handler.request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+
             Appsignal::Rack::EventHandler
               .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
-              next unless event_handler.request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
-
               transaction.finish_event("process_request.rack", "", "")
               transaction.set_http_or_background_queue_start
-
-              # Make sure the current transaction is always closed when the request
-              # is finished. This is a fallback for in case the `on_finish`
-              # callback is not called. This is supported by servers like Puma and
-              # Unicorn.
-              #
-              # The EventHandler.on_finish callback should be called first, this is
-              # just a fallback if that doesn't get called.
-              Appsignal::Transaction.complete_current!
             end
+
+            # Make sure the current transaction is always closed when the request
+            # is finished. This is a fallback for in case the `on_finish`
+            # callback is not called. This is supported by servers like Puma and
+            # Unicorn.
+            #
+            # The EventHandler.on_finish callback should be called first, this is
+            # just a fallback if that doesn't get called.
+            Appsignal::Transaction.complete_current!
           end
           transaction.start_event
         end
@@ -70,31 +72,40 @@ module Appsignal
           transaction = request.env[APPSIGNAL_TRANSACTION]
           return unless transaction
 
+          request.env[APPSIGNAL_EVENT_HANDLER_HAS_ERROR] = true
           transaction.set_error(error)
         end
       end
 
       def on_finish(request, response)
-        self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
-          return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+        return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
-          transaction = request.env[APPSIGNAL_TRANSACTION]
-          return unless transaction
+        transaction = request.env[APPSIGNAL_TRANSACTION]
+        return unless transaction
 
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
           transaction.finish_event("process_request.rack", "", "")
-          transaction.set_tags(:response_status => response.status)
           transaction.set_http_or_background_queue_start
-          Appsignal.increment_counter(
-            :response_status,
-            1,
-            :status => response.status,
-            :namespace => format_namespace(transaction.namespace)
-          )
-
-          # Make sure the current transaction is always closed when the request
-          # is finished
-          Appsignal::Transaction.complete_current!
+          response_status =
+            if response
+              response.status
+            elsif request.env[APPSIGNAL_EVENT_HANDLER_HAS_ERROR] == true
+              500
+            end
+          if response_status
+            transaction.set_tags(:response_status => response_status)
+            Appsignal.increment_counter(
+              :response_status,
+              1,
+              :status => response_status,
+              :namespace => format_namespace(transaction.namespace)
+            )
+          end
         end
+
+        # Make sure the current transaction is always closed when the request
+        # is finished
+        Appsignal::Transaction.complete_current!
       end
 
       private

data/lib/appsignal/rack/grape_middleware.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    # @api private
+    class GrapeMiddleware < Appsignal::Rack::AbstractMiddleware
+      def initialize(app, options = {})
+        options[:instrument_span_name] = "process_request.grape"
+        options[:report_errors] = lambda { |env| !env["grape.skip_appsignal_error"] }
+        super
+      end
+
+      private
+
+      def add_transaction_metadata_after(transaction, request)
+        endpoint = request.env["api.endpoint"]
+        unless endpoint&.options
+          super
+          return
+        end
+
+        options = endpoint.options
+        request_method = options[:method].first.to_s.upcase
+        klass = options[:for]
+        namespace = endpoint.namespace
+        namespace = "" if namespace == "/"
+
+        path = options[:path].first.to_s
+        path = "/#{path}" if path[0] != "/"
+        path = "#{namespace}#{path}"
+
+        transaction.set_action_if_nil("#{request_method}::#{klass}##{path}")
+
+        super
+
+        transaction.set_metadata("path", path)
+      end
+    end
+  end
+end

data/lib/appsignal/rack/hanami_middleware.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    # @api private
+    class HanamiMiddleware < AbstractMiddleware
+      def initialize(app, options = {})
+        options[:params_method] ||= :params
+        options[:instrument_span_name] ||= "process_action.hanami"
+        super
+      end
+
+      private
+
+      def params_for(request)
+        ::Hanami::Action.params_class.new(request.env).to_h
+      end
+    end
+  end
+end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -3,69 +3,27 @@
 require "rack"
 
 module Appsignal
-  # @api private
   module Rack
-    class RailsInstrumentation
+    # @api private
+    class RailsInstrumentation < Appsignal::Rack::AbstractMiddleware
       def initialize(app, options = {})
-        Appsignal.internal_logger.debug "Initializing Appsignal::Rack::RailsInstrumentation"
-        @app = app
-        @options = options
+        options[:request_class] ||= ActionDispatch::Request
+        options[:params_method] ||= :filtered_parameters
+        options[:instrument_span_name] = nil
+        options[:report_errors] = true
+        super
       end
 
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          @app.call(env)
-        end
-      end
-
-      def call_with_appsignal_monitoring(env)
-        request = ActionDispatch::Request.new(env)
-        transaction = env.fetch(
-          Appsignal::Rack::APPSIGNAL_TRANSACTION,
-          Appsignal::Transaction::NilTransaction.new
-        )
-
-        begin
-          transaction.params = fetch_params(request)
-
-          @app.call(env)
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          transaction.set_error(error)
-          raise error
-        ensure
-          controller = env["action_controller.instance"]
-          if controller
-            transaction.set_action_if_nil("#{controller.class}##{controller.action_name}")
-          end
-          request_id = fetch_request_id(env)
-          transaction.set_tags(:request_id => request_id) if request_id
-          transaction.set_metadata("path", request.path)
-          request_method = fetch_request_method(request)
-          transaction.set_metadata("method", request_method) if request_method
-        end
-      end
-
-      def fetch_request_id(env)
-        env["action_dispatch.request_id"]
-      end
+      private
 
-      def fetch_params(request)
-        return unless request.respond_to?(:filtered_parameters)
+      def add_transaction_metadata_after(transaction, request)
+        controller = request.env["action_controller.instance"]
+        transaction.set_action_if_nil("#{controller.class}##{controller.action_name}") if controller
 
-        request.filtered_parameters
-      rescue => error
-        # Getting params from the request has been know to fail.
-        Appsignal.internal_logger.debug "Exception while getting Rails params: #{error}"
-        nil
-      end
+        request_id = request.env["action_dispatch.request_id"]
+        transaction.set_tags(:request_id => request_id) if request_id
 
-      def fetch_request_method(request)
-        request.request_method
-      rescue => error
-        Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
-        nil
+        super
       end
     end
   end