appsignal 2.5.0.alpha.1-java

data/lib/appsignal/garbage_collection_profiler.rb

@@ -0,0 +1,48 @@
+module Appsignal
+  # {Appsignal::GarbageCollectionProfiler} wraps Ruby's `GC::Profiler` to be
+  # able to track garbage collection time for multiple transactions, while
+  # constantly clearing `GC::Profiler`'s total_time to make sure it doesn't
+  # leak memory by keeping garbage collection run samples in memory.
+  #
+  # @api private
+  class GarbageCollectionProfiler
+    def self.lock
+      @lock ||= Mutex.new
+    end
+
+    def initialize
+      @total_time = 0
+    end
+
+    # Whenever {#total_time} is called, the current `GC::Profiler#total_time`
+    # gets added to `@total_time`, after which `GC::Profiler.clear` is called
+    # to prevent it from leaking memory. A class-level lock is used to make
+    # sure garbage collection time is never counted more than once.
+    #
+    # Whenever `@total_time` gets above two billion milliseconds (about 23
+    # days), it's reset to make sure the result fits in a signed 32-bit
+    # integer.
+    #
+    # @return [Integer]
+    def total_time
+      lock.synchronize do
+        @total_time += (internal_profiler.total_time * 1000).round
+        internal_profiler.clear
+      end
+
+      @total_time = 0 if @total_time > 2_000_000_000
+
+      @total_time
+    end
+
+    private
+
+    def internal_profiler
+      GC::Profiler
+    end
+
+    def lock
+      self.class.lock
+    end
+  end
+end

data/lib/appsignal/hooks.rb

@@ -0,0 +1,105 @@
+module Appsignal
+  # @api private
+  class Hooks
+    class << self
+      def register(name, hook)
+        hooks[name] = hook
+      end
+
+      def load_hooks
+        hooks.each do |name, hook|
+          hook.try_to_install(name)
+        end
+      end
+
+      def hooks
+        @hooks ||= {}
+      end
+    end
+
+    class Hook
+      def self.register(name, hook = self)
+        Appsignal::Hooks.register(name, hook.new)
+      end
+
+      def initialize
+        @installed = false
+      end
+
+      def try_to_install(name)
+        if dependencies_present? && !installed?
+          Appsignal.logger.info("Installing #{name} hook")
+          begin
+            install
+            @installed = true
+          rescue => ex
+            Appsignal.logger.error("Error while installing #{name} hook: #{ex}")
+          end
+        end
+      end
+
+      def installed?
+        @installed
+      end
+
+      def dependencies_present?
+        raise NotImplementedError
+      end
+
+      def install
+        raise NotImplementedError
+      end
+    end
+
+    module Helpers
+      def string_or_inspect(string_or_other)
+        if string_or_other.is_a?(String)
+          string_or_other
+        else
+          string_or_other.inspect
+        end
+      end
+
+      def truncate(text)
+        text.size > 200 ? "#{text[0...197]}..." : text
+      end
+
+      def extract_value(object_or_hash, field, default_value = nil, convert_to_s = false)
+        value =
+          if object_or_hash.respond_to?(:[])
+            begin
+              object_or_hash[field]
+            rescue NameError
+              nil
+            end
+          elsif object_or_hash.respond_to?(field)
+            object_or_hash.send(field)
+          end || default_value
+
+        if convert_to_s
+          value.to_s
+        else
+          value
+        end
+      end
+    end
+  end
+end
+
+require "appsignal/hooks/action_cable"
+require "appsignal/hooks/active_support_notifications"
+require "appsignal/hooks/celluloid"
+require "appsignal/hooks/delayed_job"
+require "appsignal/hooks/net_http"
+require "appsignal/hooks/passenger"
+require "appsignal/hooks/puma"
+require "appsignal/hooks/rake"
+require "appsignal/hooks/redis"
+require "appsignal/hooks/sequel"
+require "appsignal/hooks/shoryuken"
+require "appsignal/hooks/sidekiq"
+require "appsignal/hooks/unicorn"
+require "appsignal/hooks/mongo_ruby_driver"
+require "appsignal/hooks/webmachine"
+require "appsignal/hooks/data_mapper"
+require "appsignal/hooks/que"

data/lib/appsignal/hooks/action_cable.rb

@@ -0,0 +1,113 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class ActionCableHook < Appsignal::Hooks::Hook
+      register :action_cable
+
+      REQUEST_ID = "_appsignal_action_cable.request_id".freeze
+
+      def dependencies_present?
+        defined?(::ActiveSupport::Notifications::Instrumenter) &&
+          defined?(::ActionCable)
+      end
+
+      def install
+        patch_perform_action
+        install_callbacks
+      end
+
+      private
+
+      def patch_perform_action
+        ActionCable::Channel::Base.class_eval do
+          alias_method :original_perform_action, :perform_action
+
+          def perform_action(*args, &block)
+            # The request is only the original websocket request
+            env = connection.env
+            request = ActionDispatch::Request.new(env)
+            env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
+              request.request_id || SecureRandom.uuid
+
+            transaction = Appsignal::Transaction.create(
+              env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
+              Appsignal::Transaction::ACTION_CABLE,
+              request
+            )
+
+            begin
+              original_perform_action(*args, &block)
+            rescue Exception => exception # rubocop:disable Lint/RescueException
+              transaction.set_error(exception)
+              raise exception
+            ensure
+              transaction.params = args.first
+              transaction.set_action_if_nil("#{self.class}##{args.first["action"]}")
+              transaction.set_metadata("path", request.path)
+              transaction.set_metadata("method", "websocket")
+              Appsignal::Transaction.complete_current!
+            end
+          end
+        end
+      end
+
+      def install_callbacks
+        ActionCable::Channel::Base.set_callback :subscribe, :around, :prepend => true do |channel, inner|
+          # The request is only the original websocket request
+          env = channel.connection.env
+          request = ActionDispatch::Request.new(env)
+          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
+            request.request_id || SecureRandom.uuid
+
+          transaction = Appsignal::Transaction.create(
+            env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
+            Appsignal::Transaction::ACTION_CABLE,
+            request
+          )
+
+          begin
+            Appsignal.instrument "subscribed.action_cable" do
+              inner.call
+            end
+          rescue Exception => exception # rubocop:disable Lint/RescueException
+            transaction.set_error(exception)
+            raise exception
+          ensure
+            transaction.set_action_if_nil("#{channel.class}#subscribed")
+            transaction.set_metadata("path", request.path)
+            transaction.set_metadata("method", "websocket")
+            Appsignal::Transaction.complete_current!
+          end
+        end
+
+        ActionCable::Channel::Base.set_callback :unsubscribe, :around, :prepend => true do |channel, inner|
+          # The request is only the original websocket request
+          env = channel.connection.env
+          request = ActionDispatch::Request.new(env)
+          env[Appsignal::Hooks::ActionCableHook::REQUEST_ID] ||=
+            request.request_id || SecureRandom.uuid
+
+          transaction = Appsignal::Transaction.create(
+            env[Appsignal::Hooks::ActionCableHook::REQUEST_ID],
+            Appsignal::Transaction::ACTION_CABLE,
+            request
+          )
+
+          begin
+            Appsignal.instrument "unsubscribed.action_cable" do
+              inner.call
+            end
+          rescue Exception => exception # rubocop:disable Lint/RescueException
+            transaction.set_error(exception)
+            raise exception
+          ensure
+            transaction.set_action_if_nil("#{channel.class}#unsubscribed")
+            transaction.set_metadata("path", request.path)
+            transaction.set_metadata("method", "websocket")
+            Appsignal::Transaction.complete_current!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/active_support_notifications.rb

@@ -0,0 +1,52 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class ActiveSupportNotificationsHook < Appsignal::Hooks::Hook
+      register :active_support_notifications
+
+      BANG = "!".freeze
+
+      def dependencies_present?
+        defined?(::ActiveSupport::Notifications::Instrumenter)
+      end
+
+      def install
+        ::ActiveSupport::Notifications.class_eval do
+          def self.instrument(name, payload = {})
+            # Don't check the notifier if any subscriber is listening:
+            # AppSignal is listening
+            instrumenter.instrument(name, payload) do
+              yield payload if block_given?
+            end
+          end
+        end
+
+        ::ActiveSupport::Notifications::Instrumenter.class_eval do
+          alias instrument_without_appsignal instrument
+
+          def instrument(name, payload = {}, &block)
+            # Events that start with a bang are internal to Rails
+            instrument_this = name[0] != BANG
+
+            if instrument_this
+              transaction = Appsignal::Transaction.current
+              transaction.start_event
+            end
+
+            instrument_without_appsignal(name, payload, &block)
+          ensure
+            if instrument_this
+              title, body, body_format = Appsignal::EventFormatter.format(name, payload)
+              transaction.finish_event(
+                name.to_s,
+                title,
+                body,
+                body_format
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/celluloid.rb

@@ -0,0 +1,30 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class CelluloidHook < Appsignal::Hooks::Hook
+      register :celluloid
+
+      def dependencies_present?
+        defined?(::Celluloid)
+      end
+
+      def install
+        # Some versions of Celluloid have race conditions while exiting
+        # that can result in a dead lock. We stop appsignal before shutting
+        # down Celluloid so we're sure our thread does not aggravate this situation.
+        # This way we also make sure any outstanding transactions get flushed.
+
+        ::Celluloid.class_eval do
+          class << self
+            alias shutdown_without_appsignal shutdown
+
+            def shutdown
+              Appsignal.stop("celluloid")
+              shutdown_without_appsignal
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/data_mapper.rb

@@ -0,0 +1,18 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class DataMapperHook < Appsignal::Hooks::Hook
+      register :data_mapper
+
+      def dependencies_present?
+        defined?(::DataMapper) &&
+          defined?(::DataObjects::Connection)
+      end
+
+      def install
+        require "appsignal/integrations/data_mapper"
+        ::DataObjects::Connection.send(:include, Appsignal::Hooks::DataMapperLogListener)
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/delayed_job.rb

@@ -0,0 +1,19 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class DelayedJobHook < Appsignal::Hooks::Hook
+      register :delayed_job
+
+      def dependencies_present?
+        defined?(::Delayed::Plugin)
+      end
+
+      def install
+        # The DJ plugin is a subclass of Delayed::Plugin, so we can only
+        # require this code if we're actually installing.
+        require "appsignal/integrations/delayed_job_plugin"
+        ::Delayed::Worker.plugins << Appsignal::Hooks::DelayedJobPlugin
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/mongo_ruby_driver.rb

@@ -0,0 +1,21 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class MongoRubyDriverHook < Appsignal::Hooks::Hook
+      register :mongo_ruby_driver
+
+      def dependencies_present?
+        defined?(::Mongo::Monitoring::Global)
+      end
+
+      def install
+        require "appsignal/integrations/mongo_ruby_driver"
+
+        Mongo::Monitoring::Global.subscribe(
+          Mongo::Monitoring::COMMAND,
+          Appsignal::Hooks::MongoMonitorSubscriber.new
+        )
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/net_http.rb

@@ -0,0 +1,29 @@
+require "net/http"
+
+module Appsignal
+  class Hooks
+    # @api private
+    class NetHttpHook < Appsignal::Hooks::Hook
+      register :net_http
+
+      def dependencies_present?
+        Appsignal.config && Appsignal.config[:instrument_net_http]
+      end
+
+      def install
+        Net::HTTP.class_eval do
+          alias request_without_appsignal request
+
+          def request(request, body = nil, &block)
+            Appsignal.instrument(
+              "request.net_http",
+              "#{request.method} #{use_ssl? ? "https" : "http"}://#{request["host"] || address}"
+            ) do
+              request_without_appsignal(request, body, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/passenger.rb

@@ -0,0 +1,22 @@
+module Appsignal
+  class Hooks
+    # @api private
+    class PassengerHook < Appsignal::Hooks::Hook
+      register :passenger
+
+      def dependencies_present?
+        defined?(::PhusionPassenger)
+      end
+
+      def install
+        ::PhusionPassenger.on_event(:starting_worker_process) do |_forked|
+          Appsignal.forked
+        end
+
+        ::PhusionPassenger.on_event(:stopping_worker_process) do
+          Appsignal.stop("passenger")
+        end
+      end
+    end
+  end
+end