appsignal 2.8.4.beta.1 → 2.9.18.beta.1

data/lib/appsignal/helpers/metrics.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Helpers
+    module Metrics
+      def set_gauge(key, value, tags = {})
+        Appsignal::Extension.set_gauge(
+          key.to_s,
+          value.to_f,
+          Appsignal::Utils::Data.generate(tags)
+        )
+      rescue RangeError
+        Appsignal.logger
+          .warn("Gauge value #{value} for key '#{key}' is too big")
+      end
+
+      def set_host_gauge(key, value)
+        Appsignal::Extension.set_host_gauge(key.to_s, value.to_f)
+      rescue RangeError
+        Appsignal.logger
+          .warn("Host gauge value #{value} for key '#{key}' is too big")
+      end
+
+      def set_process_gauge(key, value)
+        Appsignal::Extension.set_process_gauge(key.to_s, value.to_f)
+      rescue RangeError
+        Appsignal.logger
+          .warn("Process gauge value #{value} for key '#{key}' is too big")
+      end
+
+      def increment_counter(key, value = 1.0, tags = {})
+        Appsignal::Extension.increment_counter(
+          key.to_s,
+          value.to_f,
+          Appsignal::Utils::Data.generate(tags)
+        )
+      rescue RangeError
+        Appsignal.logger
+          .warn("Counter value #{value} for key '#{key}' is too big")
+      end
+
+      def add_distribution_value(key, value, tags = {})
+        Appsignal::Extension.add_distribution_value(
+          key.to_s,
+          value.to_f,
+          Appsignal::Utils::Data.generate(tags)
+        )
+      rescue RangeError
+        Appsignal.logger
+          .warn("Distribution value #{value} for key '#{key}' is too big")
+      end
+    end
+  end
+end

data/lib/appsignal/hooks.rb

@@ -29,14 +29,17 @@ module Appsignal
       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
+        return unless dependencies_present?
+        return if installed?
+
+        Appsignal.logger.info("Installing #{name} hook")
+        begin
+          install
+          @installed = true
+        rescue => ex
+          logger = Appsignal.logger
+          logger.error("Error while installing #{name} hook: #{ex}")
+          logger.debug ex.backtrace.join("\n")
         end
       end
 

data/lib/appsignal/hooks/active_support_notifications.rb

@@ -30,16 +30,13 @@ module Appsignal
             # 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
+            Appsignal::Transaction.current.start_event if instrument_this
 
             instrument_without_appsignal(name, payload, &block)
           ensure
             if instrument_this
               title, body, body_format = Appsignal::EventFormatter.format(name, payload)
-              transaction.finish_event(
+              Appsignal::Transaction.current.finish_event(
                 name.to_s,
                 title,
                 body,

data/lib/appsignal/hooks/puma.rb

@@ -7,22 +7,28 @@ module Appsignal
       register :puma
 
       def dependencies_present?
-        defined?(::Puma) &&
-          ::Puma.respond_to?(:cli_config) &&
-          ::Puma.cli_config
+        defined?(::Puma)
       end
 
       def install
-        ::Puma.cli_config.options[:before_worker_boot] ||= []
-        ::Puma.cli_config.options[:before_worker_boot] << proc do |_id|
-          Appsignal.forked
-        end
-
-        ::Puma.cli_config.options[:before_worker_shutdown] ||= []
-        ::Puma.cli_config.options[:before_worker_shutdown] << proc do |_id|
-          Appsignal.stop("puma before_worker_shutdown")
+        if ::Puma.respond_to?(:stats) && !defined?(APPSIGNAL_PUMA_PLUGIN_LOADED)
+          # Only install the minutely probe if a user isn't using our Puma
+          # plugin, which lives in `lib/puma/appsignal.rb`. This plugin defines
+          # the {APPSIGNAL_PUMA_PLUGIN_LOADED} constant.
+          #
+          # We prefer people use the AppSignal Puma plugin. This fallback is
+          # only there when users relied on our *magic* integration.
+          #
+          # Using the Puma plugin, the minutely probe thread will still run in
+          # Puma workers, for other non-Puma probes, but the Puma probe only
+          # runs in the Puma main process.
+          # For more information:
+          # https://docs.appsignal.com/ruby/integrations/puma.html
+          Appsignal::Minutely.probes.register :puma, PumaProbe
         end
 
+        return unless defined?(::Puma::Cluster)
+        # For clustered mode with multiple workers
         ::Puma::Cluster.class_eval do
           alias stop_workers_without_appsignal stop_workers
 
@@ -33,5 +39,62 @@ module Appsignal
         end
       end
     end
+
+    class PumaProbe
+      def initialize
+        @hostname = Appsignal.config[:hostname] || Socket.gethostname
+      end
+
+      def call
+        puma_stats = fetch_puma_stats
+        return unless puma_stats
+
+        stats = JSON.parse puma_stats, :symbolize_names => true
+        counts = {}
+        count_keys = [:backlog, :running, :pool_capacity, :max_threads]
+
+        if stats[:worker_status] # Multiple workers
+          stats[:worker_status].each do |worker|
+            stat = worker[:last_status]
+            count_keys.each do |key|
+              count_if_present counts, key, stat
+            end
+          end
+
+          gauge(:workers, stats[:workers], :type => :count)
+          gauge(:workers, stats[:booted_workers], :type => :booted)
+          gauge(:workers, stats[:old_workers], :type => :old)
+        else # Single worker
+          count_keys.each do |key|
+            count_if_present counts, key, stats
+          end
+        end
+
+        gauge(:connection_backlog, counts[:backlog]) if counts[:backlog]
+        gauge(:pool_capacity, counts[:pool_capacity]) if counts[:pool_capacity]
+        gauge(:threads, counts[:running], :type => :running) if counts[:running]
+        gauge(:threads, counts[:max_threads], :type => :max) if counts[:max_threads]
+      end
+
+      private
+
+      attr_reader :hostname
+
+      def gauge(field, count, tags = {})
+        Appsignal.set_gauge("puma_#{field}", count, tags.merge(:hostname => hostname))
+      end
+
+      def count_if_present(counts, key, stats)
+        stat_value = stats[key]
+        return unless stat_value
+        counts[key] ||= 0
+        counts[key] += stat_value
+      end
+
+      def fetch_puma_stats
+        ::Puma.stats
+      rescue NoMethodError # rubocop:disable Lint/HandleExceptions
+      end
+    end
   end
 end

data/lib/appsignal/hooks/sequel.rb

@@ -42,7 +42,7 @@ module Appsignal
 
       def install
         # Register the extension...
-        if ::Sequel::MAJOR >= 4 && ::Sequel::MINOR >= 35
+        if (::Sequel::MAJOR >= 4 && ::Sequel::MINOR >= 35) || ::Sequel::MAJOR >= 5
           ::Sequel::Database.register_extension(
             :appsignal_integration,
             Appsignal::Hooks::SequelLogConnectionExtension

data/lib/appsignal/hooks/sidekiq.rb

@@ -12,6 +12,8 @@ module Appsignal
       end
 
       def install
+        Appsignal::Minutely.probes.register :sidekiq, SidekiqProbe
+
         ::Sidekiq.configure_server do |config|
           config.server_middleware do |chain|
             chain.add Appsignal::Hooks::SidekiqPlugin
@@ -20,6 +22,104 @@ module Appsignal
       end
     end
 
+    class SidekiqProbe
+      attr_reader :config
+
+      def self.dependencies_present?
+        Gem::Version.new(::Redis::VERSION) >= Gem::Version.new("3.3.5")
+      end
+
+      def initialize(config = {})
+        @config = config
+        @cache = {}
+        config_string = " with config: #{config}" unless config.empty?
+        Appsignal.logger.debug("Initializing Sidekiq probe#{config_string}")
+        require "sidekiq/api"
+      end
+
+      def call
+        track_redis_info
+        track_stats
+        track_queues
+      end
+
+      private
+
+      attr_reader :cache
+
+      def track_redis_info
+        return unless ::Sidekiq.respond_to?(:redis_info)
+        redis_info = ::Sidekiq.redis_info
+
+        gauge "connection_count", redis_info.fetch("connected_clients")
+        gauge "memory_usage", redis_info.fetch("used_memory")
+        gauge "memory_usage_rss", redis_info.fetch("used_memory_rss")
+      end
+
+      def track_stats
+        stats = ::Sidekiq::Stats.new
+
+        gauge "worker_count", stats.workers_size
+        gauge "process_count", stats.processes_size
+        gauge_delta :jobs_processed, "job_count", stats.processed,
+          :status => :processed
+        gauge_delta :jobs_failed, "job_count", stats.failed, :status => :failed
+        gauge "job_count", stats.retry_size, :status => :retry_queue
+        gauge_delta :jobs_dead, "job_count", stats.dead_size, :status => :died
+        gauge "job_count", stats.scheduled_size, :status => :scheduled
+        gauge "job_count", stats.enqueued, :status => :enqueued
+      end
+
+      def track_queues
+        ::Sidekiq::Queue.all.each do |queue|
+          gauge "queue_length", queue.size, :queue => queue.name
+          # Convert latency from seconds to milliseconds
+          gauge "queue_latency", queue.latency * 1_000.0, :queue => queue.name
+        end
+      end
+
+      # Track a gauge metric with the `sidekiq_` prefix
+      def gauge(key, value, tags = {})
+        tags[:hostname] = hostname if hostname
+        Appsignal.set_gauge "sidekiq_#{key}", value, tags
+      end
+
+      # Track the delta of two values for a gauge metric
+      #
+      # First call will store the data for the metric and the second call will
+      # set a gauge metric with the difference. This is used for absolute
+      # counter values which we want to track as gauges.
+      #
+      # @example
+      #   gauge_delta :my_cache_key, "my_gauge", 10
+      #   gauge_delta :my_cache_key, "my_gauge", 15
+      #   # Creates a gauge with the value `5`
+      # @see #gauge
+      def gauge_delta(cache_key, key, value, tags = {})
+        previous_value = cache[cache_key]
+        cache[cache_key] = value
+        return unless previous_value
+        new_value = value - previous_value
+        gauge key, new_value, tags
+      end
+
+      def hostname
+        return @hostname if defined?(@hostname)
+        if config.key?(:hostname)
+          @hostname = config[:hostname]
+          Appsignal.logger.debug "Sidekiq probe: Using hostname config " \
+            "option #{@hostname.inspect} as hostname"
+          return @hostname
+        end
+
+        host = nil
+        ::Sidekiq.redis { |c| host = c.connection[:host] }
+        Appsignal.logger.debug "Sidekiq probe: Using Redis server hostname " \
+          "#{host.inspect} as hostname"
+        @hostname = host
+      end
+    end
+
     # @api private
     class SidekiqPlugin # rubocop:disable Metrics/ClassLength
       include Appsignal::Hooks::Helpers
@@ -31,6 +131,7 @@ module Appsignal
       ].freeze
 
       def call(_worker, item, _queue)
+        job_status = nil
         transaction = Appsignal::Transaction.create(
           SecureRandom.uuid,
           Appsignal::Transaction::BACKGROUND_JOB,
@@ -43,6 +144,7 @@ module Appsignal
           begin
             yield
           rescue Exception => exception # rubocop:disable Lint/RescueException
+            job_status = :failed
             transaction.set_error(exception)
             raise exception
           end
@@ -56,11 +158,24 @@ module Appsignal
           end
           transaction.set_http_or_background_queue_start
           Appsignal::Transaction.complete_current!
+          queue = item["queue"] || "unknown"
+          if job_status
+            increment_counter "queue_job_count", 1,
+              :queue => queue,
+              :status => job_status
+          end
+          increment_counter "queue_job_count", 1,
+            :queue => queue,
+            :status => :processed
         end
       end
 
       private
 
+      def increment_counter(key, value, tags = {})
+        Appsignal.increment_counter "sidekiq_#{key}", value, tags
+      end
+
       def formatted_action_name(job)
         sidekiq_action_name = parse_action_name(job)
         complete_action = sidekiq_action_name =~ /\.|#/

data/lib/appsignal/integrations/mongo_ruby_driver.rb

@@ -51,6 +51,13 @@ module Appsignal
           Appsignal::Utils::Data.generate(command),
           Appsignal::EventFormatter::DEFAULT
         )
+
+        # Send global query metrics
+        Appsignal.add_distribution_value(
+          "mongodb_query_duration",
+          event.duration,
+          :database => event.database_name
+        )
       end
     end
   end

data/lib/appsignal/integrations/que.rb

@@ -5,16 +5,17 @@ module Appsignal
     module QuePlugin
       def self.included(base)
         base.class_eval do
-          def _run_with_appsignal
+          def _run_with_appsignal(*)
+            local_attrs = respond_to?(:que_attrs) ? que_attrs : attrs
             env = {
               :metadata    => {
-                :id        => attrs[:job_id],
-                :queue     => attrs[:queue],
-                :run_at    => attrs[:run_at].to_s,
-                :priority  => attrs[:priority],
-                :attempts  => attrs[:error_count].to_i
+                :id        => local_attrs[:job_id] || local_attrs[:id],
+                :queue     => local_attrs[:queue],
+                :run_at    => local_attrs[:run_at].to_s,
+                :priority  => local_attrs[:priority],
+                :attempts  => local_attrs[:error_count].to_i
               },
-              :params => attrs[:args]
+              :params => local_attrs[:args]
             }
 
             request = Appsignal::Transaction::GenericRequest.new(env)
@@ -31,7 +32,7 @@ module Appsignal
               transaction.set_error(error)
               raise error
             ensure
-              transaction.set_action "#{attrs[:job_class]}#run"
+              transaction.set_action "#{local_attrs[:job_class]}#run"
               Appsignal::Transaction.complete_current!
             end
           end

data/lib/appsignal/integrations/railtie.rb

@@ -2,6 +2,7 @@
 
 Appsignal.logger.info("Loading Rails (#{Rails.version}) integration")
 
+require "appsignal/utils/rails_helper"
 require "appsignal/rack/rails_instrumentation"
 
 module Appsignal
@@ -17,7 +18,7 @@ module Appsignal
         Appsignal.config = Appsignal::Config.new(
           Rails.root,
           Rails.env,
-          :name => Rails.application.class.parent_name,
+          :name => Appsignal::Utils::RailsHelper.detected_rails_app_name,
           :log_path => Rails.root.join("log")
         )
 

data/lib/appsignal/marker.rb

@@ -53,11 +53,10 @@ module Appsignal
         "revision: #{marker_data[:revision]}, user: #{marker_data[:user]}"
 
       response = transmitter.transmit(marker_data)
-      if response.code == "200"
-        puts "AppSignal has been notified of this deploy!"
-      else
+      unless response.code == "200"
         raise "#{response.code} at #{transmitter.uri}"
       end
+      puts "AppSignal has been notified of this deploy!"
     rescue => e
       puts "Something went wrong while trying to notify AppSignal: #{e}"
     end

data/lib/appsignal/minutely.rb

@@ -1,44 +1,213 @@
 # frozen_string_literal: true
 
 module Appsignal
-  # @api private
   class Minutely
+    class ProbeCollection
+      include Appsignal::Utils::DeprecationMessage
+
+      def initialize
+        @probes = {}
+      end
+
+      # @return [Integer] Number of probes that are registered.
+      def count
+        probes.count
+      end
+
+      # Clears all probes from the list.
+      # @return [void]
+      def clear
+        probes.clear
+      end
+
+      # Fetch a probe using its name.
+      # @param key [Symbol/String] The name of the probe to fetch.
+      # @return [Object] Returns the registered probe.
+      def [](key)
+        probes[key]
+      end
+
+      # @param probe [Object] Any object that listens to the `call` method will
+      #   be used as a probe.
+      # @deprecated Use {#register} instead.
+      # @return [void]
+      def <<(probe)
+        deprecation_message "Deprecated `Appsignal::Minute.probes <<` " \
+          "call. Please use `Appsignal::Minutely.probes.register` instead.",
+          logger
+        register probe.object_id, probe
+      end
+
+      # Register a new minutely probe.
+      #
+      # Supported probe types are:
+      #
+      # - Lambda - A lambda is an object that listens to a `call` method call.
+      #   This `call` method is called every minute.
+      # - Class - A class object is an object that listens to a `new` and
+      #   `call` method call. The `new` method is called when the Minutely
+      #   probe thread is started to initialize all probes. This allows probes
+      #   to load dependencies once beforehand. Their `call` method is called
+      #   every minute.
+      # - Class instance - A class instance object is an object that listens to
+      #   a `call` method call. The `call` method is called every minute.
+      #
+      # @example Register a new probe
+      #   Appsignal::Minutely.probes.register :my_probe, lambda {}
+      #
+      # @example Overwrite an existing registered probe
+      #   Appsignal::Minutely.probes.register :my_probe, lambda {}
+      #   Appsignal::Minutely.probes.register :my_probe, lambda { puts "hello" }
+      #
+      # @example Add a lambda as a probe
+      #   Appsignal::Minutely.probes.register :my_probe, lambda { puts "hello" }
+      #   # "hello" # printed every minute
+      #
+      # @example Add a probe instance
+      #   class MyProbe
+      #     def initialize
+      #       puts "started"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #   end
+      #
+      #   Appsignal::Minutely.probes.register :my_probe, MyProbe.new
+      #   # "started" # printed immediately
+      #   # "called" # printed every minute
+      #
+      # @example Add a probe class
+      #   class MyProbe
+      #     def initialize
+      #       # Add things that only need to be done on start up for this probe
+      #       require "some/library/dependency"
+      #       @cache = {} # initialize a local cache variable
+      #       puts "started"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #   end
+      #
+      #   Appsignal::Minutely.probes.register :my_probe, MyProbe
+      #   Appsignal::Minutely.start # This is called for you
+      #   # "started" # Printed on Appsignal::Minutely.start
+      #   # "called" # Repeated every minute
+      #
+      # @param name [Symbol/String] Name of the probe. Can be used with {[]}.
+      #   This name will be used in errors in the log and allows overwriting of
+      #   probes by registering new ones with the same name.
+      # @param probe [Object] Any object that listens to the `call` method will
+      #   be used as a probe.
+      # @return [void]
+      def register(name, probe)
+        if probes.key?(name)
+          logger.debug "A probe with the name `#{name}` is already " \
+            "registered. Overwriting the entry with the new probe."
+        end
+        probes[name] = probe
+      end
+
+      # @api private
+      def each(&block)
+        probes.each(&block)
+      end
+
+      private
+
+      attr_reader :probes
+
+      def logger
+        Appsignal.logger
+      end
+    end
+
     class << self
-      # List of probes. Probes can be lamdba's or objects that
-      # respond to call.
+      # @see ProbeCollection
+      # @return [ProbeCollection] Returns list of probes.
       def probes
-        @@probes ||= []
+        @@probes ||= ProbeCollection.new
       end
 
+      # @api private
       def start
-        Thread.new do
-          begin
-            loop do
-              Appsignal.logger.debug("Gathering minutely metrics with #{probes.count} probe(s)")
-              probes.each(&:call)
-              sleep(wait_time)
+        stop
+        @@thread = Thread.new do
+          sleep initial_wait_time
+          initialize_probes
+          loop do
+            logger = Appsignal.logger
+            logger.debug("Gathering minutely metrics with #{probe_instances.count} probes")
+            probe_instances.each do |name, probe|
+              begin
+                logger.debug("Gathering minutely metrics with '#{name}' probe")
+                probe.call
+              rescue => ex
+                logger.error "Error in minutely probe '#{name}': #{ex}"
+                logger.debug ex.backtrace.join("\n")
+              end
             end
-          rescue => ex
-            Appsignal.logger.error("Error in minutely thread: #{ex}")
+            sleep wait_time
           end
         end
       end
 
+      # @api private
+      def stop
+        defined?(@@thread) && @@thread.kill
+        probe_instances.clear
+      end
+
+      # @api private
       def wait_time
         60 - Time.now.sec
       end
 
-      def add_gc_probe
-        probes << GCProbe.new
+      private
+
+      def initial_wait_time
+        remaining_seconds = 60 - Time.now.sec
+        return remaining_seconds if remaining_seconds > 30
+        remaining_seconds + 60
       end
-    end
 
-    class GCProbe
-      def call
-        GC.stat.each do |key, value|
-          Appsignal.set_process_gauge("gc.#{key}", value)
+      def initialize_probes
+        probes.each do |name, probe|
+          initialize_probe(name, probe)
         end
       end
+
+      def initialize_probe(name, probe)
+        if probe.respond_to? :new
+          instance = probe.new
+          klass = probe
+        else
+          instance = probe
+          klass = instance.class
+        end
+        unless dependencies_present?(klass)
+          Appsignal.logger.debug "Skipping '#{name}' probe, " \
+            "#{klass}.dependency_present? returned falsy"
+          return
+        end
+        probe_instances[name] = instance
+      rescue => error
+        logger = Appsignal.logger
+        logger.error "Error while initializing minutely probe '#{name}': #{error}"
+        logger.debug error.backtrace.join("\n")
+      end
+
+      def dependencies_present?(probe)
+        return true unless probe.respond_to? :dependencies_present?
+        probe.dependencies_present?
+      end
+
+      def probe_instances
+        @@probe_instances ||= {}
+      end
     end
   end
 end