appsignal 3.9.2 → 3.9.3

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
 
@@ -70,6 +72,7 @@ module Appsignal
           transaction = request.env[APPSIGNAL_TRANSACTION]
           return unless transaction
 
+          request.env[APPSIGNAL_EVENT_HANDLER_HAS_ERROR] = true
           transaction.set_error(error)
         end
       end
@@ -83,12 +86,18 @@ module Appsignal
         self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
           transaction.finish_event("process_request.rack", "", "")
           transaction.set_http_or_background_queue_start
-          if response
-            transaction.set_tags(:response_status => response.status)
+          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,
+              :status => response_status,
               :namespace => format_namespace(transaction.namespace)
             )
           end

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

@@ -5,7 +5,6 @@ module Appsignal
     # @api private
     class HanamiMiddleware < AbstractMiddleware
       def initialize(app, options = {})
-        options[:request_class] ||= ::Hanami::Action::Request
         options[:params_method] ||= :params
         options[:instrument_span_name] ||= "process_action.hanami"
         super
@@ -14,16 +13,7 @@ module Appsignal
       private
 
       def params_for(request)
-        super&.to_h
-      end
-
-      def request_for(env)
-        params = ::Hanami::Action.params_class.new(env)
-        @request_class.new(
-          :env => env,
-          :params => params,
-          :sessions_enabled => true
-        )
+        ::Hanami::Action.params_class.new(request.env).to_h
       end
     end
   end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -3,68 +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
-        )
+      private
 
-        begin
-          @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
-          transaction.set_params_if_nil(fetch_params(request))
-          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 add_transaction_metadata_after(transaction, request)
+        controller = request.env["action_controller.instance"]
+        transaction.set_action_if_nil("#{controller.class}##{controller.action_name}") if controller
 
-      def fetch_request_id(env)
-        env["action_dispatch.request_id"]
-      end
-
-      def fetch_params(request)
-        return unless request.respond_to?(:filtered_parameters)
-
-        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

data/lib/appsignal/utils/integration_memory_logger.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Appsignal
+  module Utils
+    # @api private
+    class IntegrationMemoryLogger
+      LEVELS = {
+        Logger::DEBUG => :DEBUG,
+        Logger::INFO => :INFO,
+        Logger::WARN => :WARN,
+        Logger::ERROR => :ERROR,
+        Logger::FATAL => :FATAL,
+        Logger::UNKNOWN => :UNKNOWN
+      }.freeze
+
+      attr_accessor :formatter, :level
+
+      def add(severity, message, _progname = nil)
+        message = formatter.call(severity, Time.now, nil, message) if formatter
+        messages[severity] << message
+      end
+      alias log add
+
+      def debug(message)
+        add(:DEBUG, message)
+      end
+
+      def info(message)
+        add(:INFO, message)
+      end
+
+      def warn(message)
+        add(:WARN, message)
+      end
+
+      def seen_keys
+        @seen_keys ||= Set.new
+      end
+
+      def warn_once_then_debug(key, message)
+        if seen_keys.add?(key).nil?
+          debug message
+        else
+          warn message
+        end
+      end
+
+      def error(message)
+        add(:ERROR, message)
+      end
+
+      def fatal(message)
+        add(:FATAL, message)
+      end
+
+      def unknown(message)
+        add(:UNKNOWN, message)
+      end
+
+      def clear
+        messages.clear
+      end
+
+      def messages
+        @messages ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def messages_for_level(level)
+        levels = LEVELS.select { |log_level| log_level >= level }.values
+        messages
+          .select { |log_level| levels.include?(log_level) }
+          .flat_map { |_level, message| message }
+      end
+    end
+  end
+end

data/lib/appsignal/utils.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "appsignal/utils/integration_memory_logger"
 require "appsignal/utils/stdout_and_logger_message"
 require "appsignal/utils/data"
 require "appsignal/utils/hash_sanitizer"

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

@@ -55,14 +55,15 @@ module Appsignal
     #   directly.
     #
     #   If no logger has been set, it will return a "in memory logger", using
-    #   `in_memory_log`. Once AppSignal is started (using {.start}) the
-    #   contents of the "in memory logger" is written to the new logger.
+    #   {Utils::IntegrationMemoryLogger}. Once AppSignal is started (using
+    #   {.start}) the contents of the "in memory logger" is written to the new
+    #   logger.
     #
     #   @note some classes may have options to set custom loggers. Their
     #     defaults are pointed to this attribute.
     #   @api private
     #   @return [Logger]
-    #   @see start_logger
+    #   @see start
     attr_writer :internal_logger
 
     # @api private
@@ -84,8 +85,6 @@ module Appsignal
     # AppSignal](https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html)
     # guide.
     #
-    # To start the logger see {.start_logger}.
-    #
     # @example
     #   Appsignal.start
     #
@@ -108,8 +107,9 @@ module Appsignal
         ENV["APPSIGNAL_APP_ENV"] || ENV["RAILS_ENV"] || ENV.fetch("RACK_ENV", nil)
       )
 
+      _start_logger
+
       if config.valid?
-        internal_logger.level = config.log_level
         if config.active?
           internal_logger.info "Starting AppSignal #{Appsignal::VERSION} " \
             "(#{$PROGRAM_NAME}, Ruby #{RUBY_VERSION}, #{RUBY_PLATFORM})"
@@ -160,7 +160,7 @@ module Appsignal
     def forked
       return unless active?
 
-      Appsignal.start_logger
+      Appsignal._start_logger
       internal_logger.debug("Forked process, resubscribing and restarting extension")
       Appsignal::Extension.start
     end
@@ -169,27 +169,15 @@ module Appsignal
       Appsignal::Extension.get_server_state(key)
     end
 
-    # In memory internal logger used before any internal logger is started with
-    # {.start_logger}.
-    #
-    # The contents of this logger are flushed to the logger in {.start_logger}.
-    #
-    # @api private
-    # @return [StringIO]
-    def in_memory_log
-      if defined?(@in_memory_log) && @in_memory_log
-        @in_memory_log
-      else
-        @in_memory_log = StringIO.new
-      end
+    def in_memory_logger
+      @in_memory_logger ||=
+        Appsignal::Utils::IntegrationMemoryLogger.new.tap do |l|
+          l.formatter = log_formatter("appsignal")
+        end
     end
 
     def internal_logger
-      @internal_logger ||=
-        Appsignal::Utils::IntegrationLogger.new(in_memory_log).tap do |l|
-          l.level = ::Logger::INFO
-          l.formatter = log_formatter("appsignal")
-        end
+      @internal_logger ||= in_memory_logger
     end
 
     # @api private
@@ -201,14 +189,26 @@ module Appsignal
       end
     end
 
+    # @deprecated Only {.start} has to be called.
+    # @return [void]
+    # @since 0.7.0
+    def start_logger
+      callers = caller
+      Appsignal::Utils::StdoutAndLoggerMessage.warning \
+        "Callng 'Appsignal.start_logger' is deprecated. " \
+          "The logger will be started when calling 'Appsignal.start'. " \
+          "Remove the 'Appsignal.start_logger' call in the following file to " \
+          "remove this message.\n#{callers.first}"
+    end
+
     # Start the AppSignal internal logger.
     #
     # Sets the log level and sets the logger. Uses a file-based logger or the
     # STDOUT-based logger. See the `:log` configuration option.
     #
+    # @api private
     # @return [void]
-    # @since 0.7.0
-    def start_logger
+    def _start_logger
       if config && config[:log] == "file" && config.log_file_path
         start_internal_file_logger(config.log_file_path)
       else
@@ -221,10 +221,11 @@ module Appsignal
         else
           Appsignal::Config::DEFAULT_LOG_LEVEL
         end
-      return unless @in_memory_log
+      return unless @in_memory_logger
 
-      internal_logger << @in_memory_log.string
-      @in_memory_log = nil
+      messages = @in_memory_logger.messages_for_level(internal_logger.level)
+      internal_logger << messages.join
+      @in_memory_logger = nil
     end
 
     # Returns if the C-extension was loaded properly.
@@ -323,11 +324,11 @@ require "appsignal/hooks"
 require "appsignal/probes"
 require "appsignal/marker"
 require "appsignal/garbage_collection"
-require "appsignal/integrations/railtie" if defined?(::Rails)
-require "appsignal/transaction"
-require "appsignal/version"
 require "appsignal/rack/abstract_middleware"
 require "appsignal/rack/generic_instrumentation"
 require "appsignal/rack/event_handler"
+require "appsignal/integrations/railtie" if defined?(::Rails)
+require "appsignal/transaction"
+require "appsignal/version"
 require "appsignal/transmitter"
 require "appsignal/heartbeat"

data/spec/.rubocop.yml

@@ -3,5 +3,5 @@ inherit_from: ../.rubocop.yml
 Metrics/BlockLength:
   Enabled: false
 
-# Metrics/LineLength:
+# Layout/LineLength:
 #   Max: 100

data/spec/lib/appsignal/cli/diagnose_spec.rb

@@ -1320,7 +1320,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
           end
 
           it "transmits path data in report" do
-            mode = ENV["RUNNING_IN_CI"] ? "40775" : "40755"
+            mode = "40755"
             expect(received_report["paths"]["root_path"]).to eq(
               "path" => root_path,
               "exists" => true,

data/spec/lib/appsignal/cli/install_spec.rb

@@ -155,7 +155,7 @@ describe Appsignal::CLI::Install do
     end
 
     it "requires an application name" do
-      expect(output.scan(/Enter application name:/).length).to eq(2)
+      expect(output.scan("Enter application name:").length).to eq(2)
     end
   end
 
@@ -184,7 +184,7 @@ describe Appsignal::CLI::Install do
           run
 
           expect(output).to_not include "Adding AppSignal integration to Capfile"
-          expect(File.read(capfile).scan(/appsignal/).count).to eq(1)
+          expect(File.read(capfile).scan("appsignal").count).to eq(1)
         end
       end
 
@@ -351,7 +351,7 @@ describe Appsignal::CLI::Install do
           choose_environment_config
           run
 
-          expect(output.scan(/Choose app's display name:/).length).to eq(2)
+          expect(output.scan("Choose app's display name:").length).to eq(2)
         end
 
         context "with configuration using environment variables" do