appsignal 3.10.0-java → 3.12.0-java

data/lib/appsignal/integrations/shoryuken.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    # @api private
+    class ShoryukenMiddleware
+      def call(worker_instance, queue, sqs_msg, body, &block)
+        transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
+
+        Appsignal.instrument("perform_job.shoryuken", &block)
+      rescue Exception => error # rubocop:disable Lint/RescueException
+        transaction.set_error(error)
+        raise
+      ensure
+        batch = sqs_msg.is_a?(Array)
+        attributes = fetch_attributes(batch, sqs_msg)
+        transaction.set_action_if_nil("#{worker_instance.class.name}#perform")
+        transaction.set_params_if_nil { fetch_args(batch, sqs_msg, body) }
+        transaction.set_tags(attributes)
+        transaction.set_tags("queue" => queue)
+        transaction.set_tags("batch" => true) if batch
+
+        if attributes.key?("SentTimestamp")
+          transaction.set_queue_start(Time.at(attributes["SentTimestamp"].to_i).to_i)
+        end
+
+        Appsignal::Transaction.complete_current!
+      end
+
+      private
+
+      def fetch_attributes(batch, sqs_msg)
+        if batch
+          # We can't instrument batched message separately, the `yield` will
+          # perform all the batched messages.
+          # To provide somewhat useful metadata, Get first message based on
+          # SentTimestamp, and use its attributes as metadata for the
+          # transaction. We can't combine them all because then they would
+          # overwrite each other and the last message (in an sorted order)
+          # would be used as the source of the metadata.  With the
+          # oldest/first message at least some useful information is stored
+          # such as the first received time and the number of retries for the
+          # first message. The newer message should have lower values and
+          # timestamps in their metadata.
+          first_msg =
+            sqs_msg.min do |a, b|
+              a.attributes["SentTimestamp"].to_i <=> b.attributes["SentTimestamp"].to_i
+            end
+          first_msg.attributes
+        else
+          sqs_msg.attributes.merge(:message_id => sqs_msg.message_id)
+        end
+      end
+
+      def fetch_args(batch, sqs_msg, body)
+        if batch
+          bodies = {}
+          sqs_msg.each_with_index do |msg, index|
+            # Store all separate bodies on a hash with the key being the
+            # message_id
+            bodies[msg.message_id] = body[index]
+          end
+          bodies
+        else
+          case body
+          when Hash
+            body
+          else
+            { :params => body }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/sidekiq.rb

@@ -11,6 +11,7 @@ module Appsignal
     # about completing the transaction.
     #
     # Introduced in Sidekiq 5.1.
+    # @api private
     class SidekiqDeathHandler
       def call(_job_context, exception)
         return unless Appsignal.config[:sidekiq_report_errors] == "discard"
@@ -37,12 +38,7 @@ module Appsignal
           # Sidekiq error outside of the middleware scope.
           # Can be a job JSON parse error or some other error happening in
           # Sidekiq.
-          transaction =
-            Appsignal::Transaction.create(
-              SecureRandom.uuid, # Newly generated job id
-              Appsignal::Transaction::BACKGROUND_JOB,
-              Appsignal::Transaction::GenericRequest.new({})
-            )
+          transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
           transaction.set_action_if_nil("SidekiqInternal")
           transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
           transaction.set_params_if_nil(:jobstr => sidekiq_context[:jobstr])
@@ -64,13 +60,7 @@ module Appsignal
 
       def call(_worker, item, _queue, &block)
         job_status = nil
-        transaction = Appsignal::Transaction.create(
-          item["jid"],
-          Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new(
-            :queue_start => item["enqueued_at"]
-          )
-        )
+        transaction = Appsignal::Transaction.create(Appsignal::Transaction::BACKGROUND_JOB)
         transaction.set_action_if_nil(formatted_action_name(item))
 
         formatted_metadata(item).each do |key, value|
@@ -83,8 +73,10 @@ module Appsignal
         raise exception
       ensure
         if transaction
-          transaction.set_params_if_nil(parse_arguments(item))
-          transaction.set_http_or_background_queue_start
+          transaction.set_params_if_nil { parse_arguments(item) }
+          queue_start = (item["enqueued_at"].to_f * 1000.0).to_i # Convert seconds to milliseconds
+          transaction.set_queue_start(queue_start)
+          transaction.set_tags(:request_id => item["jid"])
           Appsignal::Transaction.complete_current! unless exception
 
           queue = item["queue"] || "unknown"

data/lib/appsignal/integrations/sinatra.rb

@@ -1,24 +1,13 @@
 # frozen_string_literal: true
 
 require "appsignal"
-require "appsignal/rack/sinatra_instrumentation"
 
-Appsignal.internal_logger.debug("Loading Sinatra (#{Sinatra::VERSION}) integration")
+Appsignal::Utils::StdoutAndLoggerMessage.warning(
+  "The 'require \"appsignal/integrations/sinatra\"' file require integration " \
+    "method is deprecated. " \
+    "Please follow the Sinatra setup guide in our docs for the new method: " \
+    "https://docs.appsignal.com/ruby/integrations/sinatra.html"
+)
 
-unless Appsignal.active?
-  app_settings = ::Sinatra::Application.settings
-  Appsignal.config = Appsignal::Config.new(
-    app_settings.root || Dir.pwd,
-    app_settings.environment
-  )
-
-  Appsignal.start
-end
-
-if Appsignal.active?
-  ::Sinatra::Base.use(
-    ::Rack::Events,
-    [Appsignal::Rack::EventHandler.new]
-  )
-  ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
-end
+Appsignal.load(:sinatra)
+Appsignal.start

data/lib/appsignal/integrations/unicorn.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Integrations
+    # @api private
     module UnicornIntegration
       # Make sure that appsignal is started and the last transaction
       # in a worker gets flushed.

data/lib/appsignal/integrations/webmachine.rb

@@ -10,11 +10,7 @@ module Appsignal
           if has_parent_transaction
             Appsignal::Transaction.current
           else
-            Appsignal::Transaction.create(
-              SecureRandom.uuid,
-              Appsignal::Transaction::HTTP_REQUEST,
-              request
-            )
+            Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
           end
 
         Appsignal.instrument("process_action.webmachine") do
@@ -23,6 +19,7 @@ module Appsignal
       ensure
         transaction.set_action_if_nil("#{resource.class.name}##{request.method}")
         transaction.set_params_if_nil(request.query)
+        transaction.set_headers_if_nil { request.headers if request.respond_to?(:headers) }
 
         Appsignal::Transaction.complete_current! unless has_parent_transaction
       end

data/lib/appsignal/loaders/grape.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class GrapeLoader < Loader
+      register :grape
+
+      def on_load
+        require "appsignal/rack/grape_middleware"
+      end
+    end
+  end
+end

data/lib/appsignal/loaders/hanami.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class HanamiLoader < Loader
+      register :hanami
+
+      def on_load
+        hanami_app_config = ::Hanami.app.config
+        register_config_defaults(
+          :root_path => hanami_app_config.root.to_s,
+          :env => hanami_app_config.env
+        )
+      end
+
+      def on_start
+        require "appsignal/rack/hanami_middleware"
+
+        hanami_app_config = ::Hanami.app.config
+        hanami_app_config.middleware.use(
+          ::Rack::Events,
+          [Appsignal::Rack::EventHandler.new]
+        )
+        hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
+
+        ::Hanami::Action.prepend Appsignal::Loaders::HanamiLoader::HanamiIntegration
+      end
+
+      module HanamiIntegration
+        def call(env)
+          super
+        ensure
+          transaction = env[::Appsignal::Rack::APPSIGNAL_TRANSACTION]
+
+          transaction&.set_action_if_nil(self.class.name)
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/loaders/padrino.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class PadrinoLoader < Loader
+      register :padrino
+
+      def on_load
+        register_config_defaults(
+          :root_path => Padrino.mounted_root,
+          :env => Padrino.env
+        )
+      end
+
+      def on_start
+        require "appsignal/rack/sinatra_instrumentation"
+
+        Padrino::Application.prepend(Appsignal::Loaders::PadrinoLoader::PadrinoIntegration)
+
+        Padrino.before_load do
+          Padrino.use ::Rack::Events, [Appsignal::Rack::EventHandler.new]
+          Padrino.use Appsignal::Rack::SinatraBaseInstrumentation,
+            :instrument_event_name => "process_action.padrino"
+        end
+      end
+
+      module PadrinoIntegration
+        def route!(base = settings, pass_block = nil)
+          return super if !Appsignal.active? || env["sinatra.static_file"]
+
+          begin
+            super
+          ensure
+            transaction = Appsignal::Transaction.current
+            transaction.set_action_if_nil(get_payload_action(request))
+          end
+        end
+
+        private
+
+        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 ||= ""
+
+          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
+
+          # 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
+end

data/lib/appsignal/loaders/sinatra.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Loaders
+    class SinatraLoader < Loader
+      register :sinatra
+
+      def on_load
+        app_settings = ::Sinatra::Application.settings
+        register_config_defaults(
+          :root_path => app_settings.root,
+          :env => app_settings.environment
+        )
+      end
+
+      def on_start
+        require "appsignal/rack/sinatra_instrumentation"
+
+        ::Sinatra::Base.use(::Rack::Events, [Appsignal::Rack::EventHandler.new])
+        ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
+      end
+    end
+  end
+end

data/lib/appsignal/loaders.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Appsignal
+  # @api private
+  module Loaders
+    class << self
+      def loaders
+        @loaders ||= {}
+      end
+
+      def instances
+        @instances ||= {}
+      end
+
+      def register(name, klass)
+        loaders[name.to_sym] = klass
+      end
+
+      def registered?(name)
+        loaders.key?(name)
+      end
+
+      def unregister(name)
+        loaders.delete(name)
+      end
+
+      def load(name_str)
+        name = name_str.to_sym
+
+        unless registered?(name)
+          require_loader(name)
+          unless registered?(name)
+            Appsignal.internal_logger
+              .warn("No loader found with the name '#{name}'.")
+            return
+          end
+        end
+
+        Appsignal.internal_logger.debug("Loading '#{name}' loader")
+
+        begin
+          loader_klass = loaders[name]
+          loader = loader_klass.new
+          instances[name] = loader
+          loader.on_load if loader.respond_to?(:on_load)
+        rescue => e
+          Appsignal.internal_logger.error(
+            "An error occurred while loading the '#{name}' loader: " \
+              "#{e.class}: #{e.message}\n#{e.backtrace}"
+          )
+        end
+      end
+
+      def start
+        instances.each do |name, instance|
+          Appsignal.internal_logger.debug("Starting '#{name}' loader")
+          begin
+            instance.on_start if instance.respond_to?(:on_start)
+          rescue => e
+            Appsignal.internal_logger.error(
+              "An error occurred while starting the '#{name}' loader: " \
+                "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+            )
+          end
+        end
+      end
+
+      private
+
+      def require_loader(name)
+        require "appsignal/loaders/#{name}"
+      rescue LoadError
+        nil
+      end
+    end
+
+    class Loader
+      class << self
+        attr_reader :loader_name
+
+        def register(name)
+          @loader_name = name
+          Loaders.register(name, self)
+        end
+      end
+
+      def register_config_defaults(options)
+        Appsignal::Config.add_loader_defaults(self.class.loader_name, options)
+      end
+    end
+  end
+end

data/lib/appsignal/logger.rb

@@ -4,7 +4,10 @@ require "logger"
 require "set"
 
 module Appsignal
-  # Logger that flushes logs to the AppSignal logging service
+  # Logger that flushes logs to the AppSignal logging service.
+  #
+  # @see https://docs.appsignal.com/logging/platforms/integrations/ruby.html
+  #   AppSignal Ruby logging documentation.
   class Logger < ::Logger
     PLAINTEXT = 0
     LOGFMT = 1
@@ -144,8 +147,9 @@ module Appsignal
     # as our logger directly inherits from Ruby base logger.
     #
     # Links:
-    # https://github.com/rails/rails/blob/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/activesupport/lib/active_support/logger.rb#L60-L76
-    # https://github.com/rails/rails/blob/main/activesupport/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/active_support/logger_silence.rb
+    #
+    # - https://github.com/rails/rails/blob/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/activesupport/lib/active_support/logger.rb#L60-L76
+    # - https://github.com/rails/rails/blob/main/activesupport/e11ebc04cfbe41c06cdfb70ee5a9fdbbd98bb263/active_support/logger_silence.rb
     def silence(_severity = ERROR, &block)
       block.call
     end

data/lib/appsignal/probes/helpers.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Probes
+    # @api private
     module Helpers
       private
 

data/lib/appsignal/probes/mri.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Probes
+    # @api private
     class MriProbe
       include Helpers
 

data/lib/appsignal/probes/sidekiq.rb

@@ -2,6 +2,7 @@
 
 module Appsignal
   module Probes
+    # @api private
     class SidekiqProbe
       include Helpers
 

data/lib/appsignal/probes.rb

@@ -2,8 +2,10 @@
 
 module Appsignal
   module Probes
+    # @api private
     ITERATION_IN_SECONDS = 60
 
+    # @api private
     class ProbeCollection
       def initialize
         @probes = {}
@@ -72,6 +74,7 @@ module Appsignal
 
       # @see ProbeCollection
       # @return [ProbeCollection] Returns list of probes.
+      # @api private
       def probes
         @probes ||= ProbeCollection.new
       end

data/lib/appsignal/rack/abstract_middleware.rb

@@ -9,6 +9,7 @@ module Appsignal
     # Do not use this middleware directly. Instead use
     # {InstrumentationMiddleware}.
     #
+    # @abstract
     # @api private
     class AbstractMiddleware
       DEFAULT_ERROR_REPORTING = :default
@@ -33,11 +34,7 @@ module Appsignal
             if wrapped_instrumentation
               env[Appsignal::Rack::APPSIGNAL_TRANSACTION]
             else
-              Appsignal::Transaction.create(
-                SecureRandom.uuid,
-                Appsignal::Transaction::HTTP_REQUEST,
-                request
-              )
+              Appsignal::Transaction.create(Appsignal::Transaction::HTTP_REQUEST)
             end
 
           unless wrapped_instrumentation
@@ -80,7 +77,7 @@ module Appsignal
       # Either another {AbstractMiddleware} or {EventHandler} is higher in the
       # stack and will report the exception and complete the transaction.
       #
-      # @see {#instrument_app_call_with_exception_handling}
+      # @see #instrument_app_call_with_exception_handling
       def instrument_app_call(env, transaction)
         if @instrument_event_name
           Appsignal.instrument(@instrument_event_name) do
@@ -94,9 +91,10 @@ module Appsignal
       def call_app(env, transaction)
         status, headers, obody = @app.call(env)
         body =
-          if obody.is_a? Appsignal::Rack::BodyWrapper
+          if env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED]
             obody
           else
+            env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED] = true
             # Instrument response body and closing of the response body
             Appsignal::Rack::BodyWrapper.wrap(obody, transaction)
           end
@@ -108,7 +106,7 @@ module Appsignal
       # {#instrument_app_call} this will report any exceptions being
       # raised.
       #
-      # @see {#instrument_app_call}
+      # @see #instrument_app_call
       def instrument_app_call_with_exception_handling(env, transaction, wrapped_instrumentation)
         instrument_app_call(env, transaction)
       rescue Exception => error # rubocop:disable Lint/RescueException
@@ -147,7 +145,14 @@ module Appsignal
         transaction.set_metadata("method", request_method) if request_method
 
         transaction.set_params_if_nil { params_for(request) }
-        transaction.set_http_or_background_queue_start
+        transaction.set_session_data_if_nil do
+          request.session if request.respond_to?(:session)
+        end
+        transaction.set_headers_if_nil do
+          request.env if request.respond_to?(:env)
+        end
+        queue_start = Appsignal::Rack::Utils.queue_start_from(request.env)
+        transaction.set_queue_start(queue_start) if queue_start
       end
 
       def params_for(request)
@@ -155,9 +160,9 @@ module Appsignal
 
         request.send(@params_method)
       rescue => error
-        # Getting params from the request has been know to fail.
-        Appsignal.internal_logger.debug(
-          "Exception while getting params in #{self.class} from '#{@params_method}': #{error}"
+        Appsignal.internal_logger.error(
+          "Exception while fetching params from '#{@request_class}##{@params_method}': " \
+            "#{error.class} #{error}"
         )
         nil
       end
@@ -165,7 +170,9 @@ module Appsignal
       def request_method_for(request)
         request.request_method
       rescue => error
-        Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
+        Appsignal.internal_logger.error(
+          "Exception while fetching the HTTP request method: #{error.class}: #{error}"
+        )
         nil
       end