appsignal 3.9.2-java → 3.10.0-java

data/lib/appsignal/helpers/instrumentation.rb

@@ -2,7 +2,7 @@
 
 module Appsignal
   module Helpers
-    module Instrumentation # rubocop:disable Metrics/ModuleLength
+    module Instrumentation
       include Appsignal::Utils::StdoutAndLoggerMessage
 
       # Creates an AppSignal transaction for the given block.
@@ -195,6 +195,7 @@ module Appsignal
       #   used to send the error.
       # @return [void]
       #
+      # @see Transaction#report_error
       # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
       #   Exception handling guide
       # @see https://docs.appsignal.com/ruby/instrumentation/tagging.html
@@ -294,6 +295,7 @@ module Appsignal
       # @return [void]
       #
       # @see Transaction#set_error
+      # @see Transaction#report_error
       # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
       #   Exception handling guide
       # @since 0.6.6
@@ -334,6 +336,74 @@ module Appsignal
       alias :set_exception :set_error
       alias :add_exception :set_error
 
+      # Report an error.
+      #
+      # If a transaction is currently active, it will report the error on the
+      # current transaction. If no transaction is active, it will report the
+      # error on a new transaction.
+      #
+      # **Note**: If AppSignal is not active, no error is reported.
+      #
+      # **Note**: If the given exception argument is not an Exception subclass,
+      # it will not be reported.
+      #
+      # @example
+      #   class SomeController < ApplicationController
+      #     def create
+      #       # Do something that breaks
+      #     rescue => error
+      #       Appsignal.report_error(error)
+      #     end
+      #   end
+      #
+      # @example Add more metadata to transaction
+      #   Appsignal.report_error(error) do |transaction|
+      #     transaction.set_namespace("my_namespace")
+      #     transaction.set_action("my_action_name")
+      #     transaction.set_params(:search_query => params[:search_query])
+      #     transaction.set_tags(:key => "value")
+      #   end
+      #
+      # @param exception [Exception] The error to add to the current
+      #   transaction.
+      # @yield [transaction] yields block to allow modification of the
+      #   transaction.
+      # @yieldparam transaction [Transaction] yields the AppSignal transaction
+      #   used to report the error.
+      # @return [void]
+      #
+      # @see https://docs.appsignal.com/ruby/instrumentation/exception-handling.html
+      #   Exception handling guide
+      # @since 3.10.0
+      def report_error(exception)
+        unless exception.is_a?(Exception)
+          internal_logger.error "Appsignal.report_error: Cannot set error. " \
+            "The given value is not an exception: #{exception.inspect}"
+          return
+        end
+        return unless active?
+
+        has_parent_transaction = Appsignal::Transaction.current?
+        transaction =
+          if has_parent_transaction
+            Appsignal::Transaction.current
+          else
+            Appsignal::Transaction.new(
+              SecureRandom.uuid,
+              Appsignal::Transaction::HTTP_REQUEST,
+              Appsignal::Transaction::GenericRequest.new({})
+            )
+          end
+
+        transaction.set_error(exception)
+        yield transaction if block_given?
+
+        return if has_parent_transaction
+
+        transaction.complete
+      end
+      alias :report_exception :report_error
+
       # Set a custom action name for the current transaction.
       #
       # When using an integration such as the Rails or Sinatra AppSignal will
@@ -404,13 +474,44 @@ module Appsignal
         Appsignal::Transaction.current.set_namespace(namespace)
       end
 
+      # Set custom data on the current transaction.
+      #
+      # Add extra information about the request or background that cannot be
+      # expressed in tags, like nested data structures.
+      #
+      # When this method is called multiple times, it will overwrite the
+      # previously set value.
+      #
+      # @example
+      #   Appsignal.set_custom_data(:user => { :locale => "en" })
+      #   Appsignal.set_custom_data([
+      #     "array with data",
+      #     :options => { :verbose => true }
+      #   ])
+      #
+      # @since 3.10.0
+      # @see Transaction#set_custom_data
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @param data [Hash/Array]
+      # @return [void]
+      def set_custom_data(data)
+        return unless active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_custom_data(data)
+      end
+
       # Set tags on the current transaction.
       #
       # Tags are extra bits of information that are added to transaction and
       # appear on sample details pages on AppSignal.com.
       #
+      # When this method is called multiple times, it will merge the tags.
+      #
       # @example
-      #   Appsignal.tag_request(:locale => "en")
+      #   Appsignal.tag_request(:locale => "en", :user_id => 1)
       #   Appsignal.tag_request("locale" => "en")
       #   Appsignal.tag_request("user_id" => 1)
       #
@@ -445,6 +546,67 @@ module Appsignal
         transaction.set_tags(tags)
       end
       alias :tag_job :tag_request
+      alias :set_tags :tag_request
+
+      # Set parameters on the current transaction.
+      #
+      # Parameters are automatically set by most of our integrations. It should
+      # not be necessary to call this method unless you want to report
+      # different parameters.
+      #
+      # To filter parameters, see our parameter filtering guide.
+      #
+      # When this method is called multiple times, it will overwrite the
+      # previously set value.
+      #
+      # When no parameters are set this way, the transaction will look for
+      # parameters in its request environment.
+      #
+      # A block can be given to this method to defer the fetching and parsing
+      # of the parameters until and only when the transaction is sampled.
+      #
+      # When both the `params` and a block is given to this method, the
+      # `params` argument is leading and the block will _not_ be called.
+      #
+      # @example Set parameters
+      #   Appsignal.set_params("param1" => "value1")
+      #
+      # @example Calling `set_params` multiple times will only keep the last call
+      #   Appsignal.set_params("param1" => "value1")
+      #   Appsignal.set_params("param2" => "value2")
+      #   # The parameters are: { "param2" => "value2" }
+      #
+      # @example Calling `set_params` with a block
+      #   Appsignal.set_params do
+      #     # Some slow code to parse parameters
+      #     JSON.parse('{"param1": "value1"}')
+      #   end
+      #   # The parameters are: { "param1" => "value1" }
+      #
+      # @example Calling `set_params` with a parameter and a block
+      #   Appsignal.set_params("argument" => "argument value") do
+      #     # Some slow code to parse parameters
+      #     JSON.parse('{"param1": "value1"}')
+      #   end
+      #   # The parameters are: { "argument" => "argument value" }
+      #
+      # @since 3.10.0
+      # @param params [Hash] The parameters to set on the transaction.
+      # @yield This block is called when the transaction is sampled. The block's
+      #   return value will become the new parameters.
+      # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
+      #   Sample data guide
+      # @see https://docs.appsignal.com/guides/filter-data/filter-parameters.html
+      #   Parameter filtering guide
+      # @see Transaction#set_params
+      # @return [void]
+      def set_params(params = nil, &block)
+        return unless active?
+        return unless Appsignal::Transaction.current?
+
+        transaction = Appsignal::Transaction.current
+        transaction.set_params(params, &block)
+      end
 
       # Add breadcrumbs to the transaction.
       #

data/lib/appsignal/hooks/active_job.rb

@@ -62,12 +62,7 @@ module Appsignal
             end
 
           if transaction
-            transaction.set_params_if_nil(
-              Appsignal::Utils::HashSanitizer.sanitize(
-                job["arguments"],
-                Appsignal.config[:filter_parameters]
-              )
-            )
+            transaction.set_params_if_nil(job["arguments"])
 
             transaction_tags = ActiveJobHelpers.transaction_tags_for(job)
             transaction_tags["active_job_id"] = job["job_id"]

data/lib/appsignal/integrations/grape.rb

@@ -1,55 +1,27 @@
 # frozen_string_literal: true
 
+require "appsignal"
+require "appsignal/rack/grape_middleware"
+
+Appsignal.internal_logger.debug("Loading Grape integration")
+
 module Appsignal
-  # @todo Move to sub-namespace
   # @api private
   module Grape
-    class Middleware < ::Grape::Middleware::Base
-      def call(env)
-        if Appsignal.active?
-          call_with_appsignal_monitoring(env)
-        else
-          app.call(env)
-        end
-      end
-
-      def call_with_appsignal_monitoring(env)
-        request     = ::Rack::Request.new(env)
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request
-        )
-        begin
-          app.call(env)
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          # Do not set error if "grape.skip_appsignal_error" is set to `true`.
-          transaction.set_error(error) unless env["grape.skip_appsignal_error"]
-          raise error
-        ensure
-          request_method = request.request_method.to_s.upcase
-          path = request.path # Path without namespaces
-          endpoint = env["api.endpoint"]
-
-          if endpoint&.options
-            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}")
-          end
-
-          transaction.set_http_or_background_queue_start
-          transaction.set_metadata("path", path)
-          transaction.set_metadata("method", request_method)
-          Appsignal::Transaction.complete_current!
-        end
+    # Alias constants that have moved with a warning message that points to the
+    # place to update the reference.
+    def self.const_missing(name)
+      case name
+      when :Middleware
+        callers = caller
+        Appsignal::Utils::StdoutAndLoggerMessage.warning \
+          "The constant Appsignal::Grape::Middleware has been deprecated. " \
+            "Please update the constant name to " \
+            "Appsignal::Rack::GrapeMiddleware in the following file to " \
+            "remove this message.\n#{callers.first}"
+        Appsignal::Rack::GrapeMiddleware
+      else
+        super
       end
     end
   end

data/lib/appsignal/integrations/hanami.rb

@@ -11,13 +11,14 @@ module Appsignal
         Appsignal.internal_logger.debug("Loading Hanami integration")
 
         hanami_app_config = ::Hanami.app.config
-        Appsignal.config = Appsignal::Config.new(
-          hanami_app_config.root || Dir.pwd,
-          hanami_app_config.env
-        )
 
-        Appsignal.start_logger
-        Appsignal.start
+        unless Appsignal.active?
+          Appsignal.config = Appsignal::Config.new(
+            hanami_app_config.root || Dir.pwd,
+            hanami_app_config.env
+          )
+          Appsignal.start
+        end
 
         return unless Appsignal.active?
 
@@ -44,4 +45,4 @@ module Appsignal
   end
 end
 
-Appsignal::Integrations::HanamiPlugin.init
+Appsignal::Integrations::HanamiPlugin.init unless Appsignal.testing?

data/lib/appsignal/integrations/padrino.rb

@@ -1,79 +1,78 @@
 # frozen_string_literal: true
 
 require "appsignal"
+require "appsignal/rack/sinatra_instrumentation"
 
 module Appsignal
   module Integrations
     # @api private
     module PadrinoPlugin
       def self.init
-        Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
+        Padrino::Application.prepend Appsignal::Integrations::PadrinoIntegration
 
-        root = Padrino.mounted_root
-        Appsignal.config = Appsignal::Config.new(root, Padrino.env)
+        Padrino.before_load do
+          Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
 
-        Appsignal.start_logger
-        Appsignal.start
+          unless Appsignal.active?
+            root = Padrino.mounted_root
+            Appsignal.config = Appsignal::Config.new(root, Padrino.env)
+            Appsignal.start
+          end
+
+          next unless Appsignal.active?
+
+          Padrino.use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+          Padrino.use Appsignal::Rack::SinatraBaseInstrumentation,
+            :instrument_event_name => "process_action.padrino"
+        end
       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
+    # @api private
+    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
+        begin
+          super
+        ensure
+          transaction = Appsignal::Transaction.current
+          transaction.set_action_if_nil(get_payload_action(request))
+        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-circuit 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
 
-Padrino::Application.prepend Appsignal::Integrations::PadrinoIntegration
-
-Padrino.after_load do
-  Appsignal::Integrations::PadrinoPlugin.init
-end
+Appsignal::Integrations::PadrinoPlugin.init

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,

data/lib/appsignal/integrations/rake.rb

@@ -2,26 +2,60 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module RakeIntegration
       def execute(*args)
-        super
+        transaction =
+          if Appsignal.config[:enable_rake_performance_instrumentation]
+            Appsignal::Integrations::RakeIntegrationHelper.register_at_exit_hook
+            _appsignal_create_transaction
+          end
+
+        Appsignal.instrument "task.rake" do
+          super
+        end
       rescue Exception => error # rubocop:disable Lint/RescueException
-        # Format given arguments and cast to hash if possible
-        params, _ = args
-        params = params.to_hash if params.respond_to?(:to_hash)
+        Appsignal::Integrations::RakeIntegrationHelper.register_at_exit_hook
+        transaction ||= _appsignal_create_transaction
+        transaction.set_error(error)
+        raise error
+      ensure
+        if transaction
+          # Format given arguments and cast to hash if possible
+          params, _ = args
+          params = params.to_hash if params.respond_to?(:to_hash)
+          transaction.set_params_if_nil(params)
+          transaction.set_action(name)
+          transaction.complete
+        end
+      end
 
-        transaction = Appsignal::Transaction.create(
+      private
+
+      def _appsignal_create_transaction
+        Appsignal::Transaction.create(
           SecureRandom.uuid,
           Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new(
-            :params => params
-          )
+          Appsignal::Transaction::GenericRequest.new({})
         )
-        transaction.set_action(name)
-        transaction.set_error(error)
-        transaction.complete
+      end
+    end
+
+    # @api private
+    module RakeIntegrationHelper
+      # Register an `at_exit` hook when a task is executed. This will stop
+      # AppSignal when _all_ tasks are executed and Rake exits.
+      def self.register_at_exit_hook
+        return if @register_at_exit_hook
+
+        Kernel.at_exit(&method(:at_exit_hook))
+
+        @register_at_exit_hook = true
+      end
+
+      # The at_exit hook itself
+      def self.at_exit_hook
         Appsignal.stop("rake")
-        raise error
       end
     end
   end

data/lib/appsignal/integrations/sidekiq.rb

@@ -83,7 +83,7 @@ module Appsignal
         raise exception
       ensure
         if transaction
-          transaction.set_params_if_nil(filtered_arguments(item))
+          transaction.set_params_if_nil(parse_arguments(item))
           transaction.set_http_or_background_queue_start
           Appsignal::Transaction.complete_current! unless exception
 
@@ -115,16 +115,6 @@ module Appsignal
         "#{sidekiq_action_name}#perform"
       end
 
-      def filtered_arguments(job)
-        arguments = parse_arguments(job)
-        return unless arguments
-
-        Appsignal::Utils::HashSanitizer.sanitize(
-          arguments,
-          Appsignal.config[:filter_parameters]
-        )
-      end
-
       def formatted_metadata(item)
         {}.tap do |hash|
           (item || {}).each do |key, value|

data/lib/appsignal/integrations/sinatra.rb

@@ -12,7 +12,6 @@ unless Appsignal.active?
     app_settings.environment
   )
 
-  Appsignal.start_logger
   Appsignal.start
 end
 

data/lib/appsignal/integrations/webmachine.rb

@@ -5,20 +5,26 @@ module Appsignal
     # @api private
     module WebmachineIntegration
       def run
-        transaction = Appsignal::Transaction.create(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          request,
-          :params_method => :query
-        )
-
-        transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
+        has_parent_transaction = Appsignal::Transaction.current?
+        transaction =
+          if has_parent_transaction
+            Appsignal::Transaction.current
+          else
+            Appsignal::Transaction.create(
+              SecureRandom.uuid,
+              Appsignal::Transaction::HTTP_REQUEST,
+              request
+            )
+          end
 
         Appsignal.instrument("process_action.webmachine") do
           super
         end
+      ensure
+        transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
+        transaction.set_params_if_nil(request.query)
 
-        Appsignal::Transaction.complete_current!
+        Appsignal::Transaction.complete_current! unless has_parent_transaction
       end
 
       private

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