appsignal 2.8.4 → 2.9.0

data/lib/appsignal/helpers/metrics.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Helpers
+    # @api private
+    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,15 @@ 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
+          Appsignal.logger.error("Error while installing #{name} hook: #{ex}")
         end
       end
 

data/lib/appsignal/hooks/puma.rb

@@ -7,20 +7,24 @@ 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
+        if ::Puma.respond_to?(:stats)
+          Appsignal::Minutely.probes.register :puma, PumaProbe
         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?(:cli_config) && ::Puma.cli_config
+          ::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")
+          end
         end
 
         ::Puma::Cluster.class_eval do
@@ -33,5 +37,57 @@ module Appsignal
         end
       end
     end
+
+    class PumaProbe
+      def initialize
+        @hostname = Appsignal.config[:hostname] || Socket.gethostname
+      end
+
+      def call
+        return unless ::Puma.stats
+
+        stats = JSON.parse Puma.stats, :symbolize_names => true
+        counts = {
+          :backlog => 0,
+          :running => 0,
+          :pool_capacity => 0,
+          :max_threads => 0
+        }
+
+        if stats[:worker_status] # Multiple workers
+          stats[:worker_status].each do |worker|
+            stat = worker[:last_status]
+
+            counts[:backlog] += stat[:backlog]
+            counts[:running] += stat[:running]
+            counts[:pool_capacity] += stat[:pool_capacity]
+            counts[:max_threads] += stat[:max_threads]
+          end
+
+          gauge(:workers, stats[:workers], :type => :count)
+          gauge(:workers, stats[:booted_workers], :type => :booted)
+          gauge(:workers, stats[:old_workers], :type => :old)
+
+        else # Single worker
+          counts[:backlog] += stats[:backlog]
+          counts[:running] += stats[:running]
+          counts[:pool_capacity] += stats[:pool_capacity]
+          counts[:max_threads] += stats[:max_threads]
+        end
+
+        gauge(:connection_backlog, counts[:backlog])
+        gauge(:pool_capacity, counts[:pool_capacity])
+        gauge(:threads, counts[:running], :type => :running)
+        gauge(:threads, counts[:max_threads], :type => :max)
+      end
+
+      private
+
+      attr_reader :hostname
+
+      def gauge(field, count, tags = {})
+        Appsignal.set_gauge("puma_#{field}", count, tags.merge(:hostname => hostname))
+      end
+    end
   end
 end

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,79 @@ module Appsignal
       end
     end
 
+    class SidekiqProbe
+      attr_reader :config
+
+      def initialize(config = {})
+        @config = config
+        @cache = {}
+        require "sidekiq/api"
+      end
+
+      def call
+        stats = ::Sidekiq::Stats.new
+        redis_info = ::Sidekiq.redis_info
+        gauge "worker_count", stats.workers_size
+        gauge "process_count", stats.processes_size
+        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")
+        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
+
+        ::Sidekiq::Queue.all.each do |queue|
+          gauge "queue_length", queue.size, :queue => queue.name
+          gauge "queue_latency", queue.latency, :queue => queue.name
+        end
+      end
+
+      private
+
+      attr_reader :cache
+
+      # 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]
+          return @hostname
+        end
+
+        host = nil
+        ::Sidekiq.redis { |c| host = c.connection[:host] }
+        @hostname = host
+      end
+    end
+
     # @api private
     class SidekiqPlugin # rubocop:disable Metrics/ClassLength
       include Appsignal::Hooks::Helpers
@@ -31,6 +106,7 @@ module Appsignal
       ].freeze
 
       def call(_worker, item, _queue)
+        job_status = nil
         transaction = Appsignal::Transaction.create(
           SecureRandom.uuid,
           Appsignal::Transaction::BACKGROUND_JOB,
@@ -43,6 +119,7 @@ module Appsignal
           begin
             yield
           rescue Exception => exception # rubocop:disable Lint/RescueException
+            job_status = :failed
             transaction.set_error(exception)
             raise exception
           end
@@ -56,11 +133,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/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,35 +1,185 @@
 # 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
+        initialize_probes
+        @@thread = Thread.new do
+          loop do
+            logger = Appsignal.logger
+            logger.debug("Gathering minutely metrics with #{probes.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}")
+              end
             end
-          rescue => ex
-            Appsignal.logger.error("Error in minutely thread: #{ex}")
+            sleep(Appsignal::Minutely.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
+      # @api private
+      def register_garbage_collection_probe
+        probes.register :garbage_collection, GCProbe.new
+      end
+
+      private
+
+      def initialize_probes
+        probes.each do |name, probe|
+          instance = probe.respond_to?(:new) ? probe.new : probe
+          probe_instances[name] = instance
+        end
+      end
+
+      def probe_instances
+        @@probe_instances ||= {}
       end
     end