appsignal 3.4.4 → 3.7.0

data/lib/appsignal/environment.rb

@@ -10,9 +10,9 @@ module Appsignal
     #
     # The value of the environment metadata is given as a block that captures
     # errors that might be raised while fetching the value. It will not
-    # re-raise errors, but instead log them using the {Appsignal.logger}. This
-    # ensures AppSignal will not cause an error in the application when
-    # collecting this metadata.
+    # re-raise errors, but instead log them using the
+    # {Appsignal.internal_logger}. This ensures AppSignal will not cause an
+    # error in the application when collecting this metadata.
     #
     # @example Reporting a key and value
     #   Appsignal::Environment.report("ruby_version") { RUBY_VERSION }
@@ -34,8 +34,8 @@ module Appsignal
         when String
           key
         else
-          Appsignal.logger.error "Unable to report on environment metadata: " \
-            "Unsupported value type for #{key.inspect}"
+          Appsignal.internal_logger.error "Unable to report on environment " \
+            "metadata: Unsupported value type for #{key.inspect}"
           return
         end
 
@@ -43,7 +43,7 @@ module Appsignal
         begin
           yield
         rescue => e
-          Appsignal.logger.error \
+          Appsignal.internal_logger.error \
             "Unable to report on environment metadata #{key.inspect}:\n" \
               "#{e.class}: #{e}"
           return
@@ -56,26 +56,35 @@ module Appsignal
         when String
           yielded_value
         else
-          Appsignal.logger.error "Unable to report on environment metadata " \
-            "#{key.inspect}: Unsupported value type for " \
+          Appsignal.internal_logger.error "Unable to report on environment " \
+            "metadata #{key.inspect}: Unsupported value type for " \
             "#{yielded_value.inspect}"
           return
         end
 
       Appsignal::Extension.set_environment_metadata(key, value)
     rescue => e
-      Appsignal.logger.error "Unable to report on environment metadata:\n" \
-        "#{e.class}: #{e}"
+      Appsignal.internal_logger.error "Unable to report on environment " \
+        "metadata:\n#{e.class}: #{e}"
     end
 
     # @see report_supported_gems
     SUPPORTED_GEMS = %w[
       actioncable
+      actionmailer
       activejob
+      activerecord
       capistrano
       celluloid
       data_mapper
       delayed_job
+      dry-monitor
+      elasticsearch
+      excon
+      faraday
+      gvltools
+      hanami
+      hiredis
       mongo_ruby_driver
       padrino
       passenger
@@ -85,7 +94,9 @@ module Appsignal
       rails
       rake
       redis
+      redis-client
       resque
+      rom
       sequel
       shoryuken
       sidekiq
@@ -114,15 +125,15 @@ module Appsignal
         report("ruby_#{gem_name}_version") { gem_spec.version.to_s }
       end
     rescue => e
-      Appsignal.logger.error "Unable to report supported gems:\n" \
+      Appsignal.internal_logger.error "Unable to report supported gems:\n" \
         "#{e.class}: #{e}"
     end
 
     def self.report_enabled(feature)
       Appsignal::Environment.report("ruby_#{feature}_enabled") { true }
     rescue => e
-      Appsignal.logger.error "Unable to report integration enabled:\n" \
-        "#{e.class}: #{e}"
+      Appsignal.internal_logger.error "Unable to report integration " \
+        "enabled:\n#{e.class}: #{e}"
     end
   end
 end

data/lib/appsignal/event_formatter/action_view/render_formatter.rb

@@ -10,7 +10,7 @@ module Appsignal
         attr_reader :root_path
 
         def initialize
-          @root_path = "#{Rails.root}/".freeze
+          @root_path = "#{Rails.root}/"
         end
 
         def format(payload)

data/lib/appsignal/event_formatter/rom/sql_formatter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class EventFormatter
+    module Rom
+      class SqlFormatter
+        def format(payload)
+          ["query.#{payload[:name]}", payload[:query], SQL_BODY_FORMAT]
+        end
+      end
+    end
+  end
+end
+
+Appsignal::EventFormatter.register(
+  "sql.dry",
+  Appsignal::EventFormatter::Rom::SqlFormatter
+)

data/lib/appsignal/event_formatter/sequel/sql_formatter.rb

@@ -4,7 +4,7 @@ module Appsignal
   class EventFormatter
     # @api private
     module Sequel
-      # Compatability with the sequel-rails gem.
+      # Compatibility with the sequel-rails gem.
       # The sequel-rails gem adds its own ActiveSupport::Notifications events
       # that conflict with our own sequel instrumentor. Without this event
       # formatter the sequel-rails events are recorded without the SQL query

data/lib/appsignal/event_formatter.rb

@@ -73,7 +73,7 @@ module Appsignal
       end
 
       def logger
-        Appsignal.logger
+        Appsignal.internal_logger
       end
     end
 
@@ -84,6 +84,6 @@ module Appsignal
   end
 end
 
-Dir.glob(File.expand_path("event_formatter/**/*.rb", __dir__)).each do |file|
+Dir.glob(File.expand_path("event_formatter/**/*.rb", __dir__)).sort.each do |file|
   require file
 end

data/lib/appsignal/extension/jruby.rb

@@ -71,12 +71,6 @@ module Appsignal
         attach_function :appsignal_set_gauge,
           [:appsignal_string, :double, :pointer],
           :void
-        attach_function :appsignal_set_host_gauge,
-          [:appsignal_string, :double],
-          :void
-        attach_function :appsignal_set_process_gauge,
-          [:appsignal_string, :double],
-          :void
         attach_function :appsignal_increment_counter,
           [:appsignal_string, :double, :pointer],
           :void
@@ -248,14 +242,15 @@ module Appsignal
           [:pointer],
           :appsignal_string
 
-        Appsignal.extension_loaded = true
+        Appsignal.extension_loaded = true if Appsignal.respond_to? :extension_loaded=
       rescue LoadError => error
         error_message = "ERROR: AppSignal failed to load extension. " \
           "Please run `appsignal diagnose` and email us at support@appsignal.com\n" \
           "#{error.class}: #{error.message}"
-        Appsignal.logger.error(error_message)
+        Appsignal.internal_logger.error(error_message) if Appsignal.respond_to? :internal_logger
         Kernel.warn error_message
-        Appsignal.extension_loaded = false
+        Appsignal.extension_loaded = false if Appsignal.respond_to? :extension_loaded=
+        raise error if ENV["_APPSIGNAL_EXTENSION_INSTALL"] == "true"
       end
 
       def start
@@ -319,14 +314,6 @@ module Appsignal
         appsignal_set_gauge(make_appsignal_string(key), value, tags.pointer)
       end
 
-      def set_host_gauge(key, value)
-        appsignal_set_host_gauge(make_appsignal_string(key), value)
-      end
-
-      def set_process_gauge(key, value)
-        appsignal_set_process_gauge(make_appsignal_string(key), value)
-      end
-
       def increment_counter(key, value, tags)
         appsignal_increment_counter(make_appsignal_string(key), value, tags.pointer)
       end

data/lib/appsignal/extension.rb

@@ -12,7 +12,7 @@ rescue LoadError => error
   error_message = "ERROR: AppSignal failed to load extension. " \
     "Please run `appsignal diagnose` and email us at support@appsignal.com\n" \
     "#{error.class}: #{error.message}"
-  Appsignal.logger.error(error_message)
+  Appsignal.internal_logger.error(error_message)
   Kernel.warn error_message
   Appsignal.extension_loaded = false
 end

data/lib/appsignal/heartbeat.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Heartbeat
+    class << self
+      def transmitter
+        @transmitter ||= Appsignal::Transmitter.new(
+          "#{Appsignal.config[:logging_endpoint]}/heartbeats/json"
+        )
+      end
+    end
+
+    attr_reader :name, :id
+
+    def initialize(name:)
+      @name = name
+      @id = SecureRandom.hex(8)
+    end
+
+    def start
+      transmit_event("start")
+    end
+
+    def finish
+      transmit_event("finish")
+    end
+
+    private
+
+    def event(kind)
+      {
+        :name => name,
+        :id => @id,
+        :kind => kind,
+        :timestamp => Time.now.utc.to_i
+      }
+    end
+
+    def transmit_event(kind)
+      unless Appsignal.active?
+        Appsignal.internal_logger.debug("AppSignal not active, not transmitting heartbeat event")
+        return
+      end
+
+      response = self.class.transmitter.transmit(event(kind))
+
+      if response.code.to_i >= 200 && response.code.to_i < 300
+        Appsignal.internal_logger.trace("Transmitted heartbeat `#{name}` (#{id}) #{kind} event")
+      else
+        Appsignal.internal_logger.error(
+          "Failed to transmit heartbeat event: status code was #{response.code}"
+        )
+      end
+    rescue => e
+      Appsignal.internal_logger.error("Failed to transmit heartbeat event: #{e}")
+    end
+  end
+
+  def self.heartbeat(name)
+    heartbeat = Appsignal::Heartbeat.new(:name => name)
+    output = nil
+
+    if block_given?
+      heartbeat.start
+      output = yield
+    end
+
+    heartbeat.finish
+    output
+  end
+end

data/lib/appsignal/helpers/instrumentation.rb

@@ -7,8 +7,8 @@ module Appsignal
 
       # Creates an AppSignal transaction for the given block.
       #
-      # If AppSignal is not {.active?} it will still execute the block, but not
-      # create a transaction for it.
+      # If AppSignal is not {Appsignal.active?} it will still execute the
+      # block, but not create a transaction for it.
       #
       # A event is created for this transaction with the name given in the
       # `name` argument. The event name must start with either `perform_job` or
@@ -68,9 +68,9 @@ module Appsignal
           namespace = Appsignal::Transaction::HTTP_REQUEST
           request   = ::Rack::Request.new(env)
         else
-          logger.error "Unrecognized name '#{name}': names must start with " \
-            "either 'perform_job' (for jobs and tasks) or 'process_action' " \
-            "(for HTTP requests)"
+          internal_logger.error "Unrecognized name '#{name}': names must " \
+            "start with either 'perform_job' (for jobs and tasks) or " \
+            "'process_action' (for HTTP requests)"
           return yield
         end
 
@@ -112,7 +112,7 @@ module Appsignal
       # transaction. Does not add the error to the current transaction.
       #
       # Make sure that AppSignal is integrated in your application beforehand.
-      # AppSignal won't record errors unless {Config#active?} is `true`.
+      # AppSignal won't record errors unless {Appsignal.active?} is `true`.
       #
       # @example
       #   # my_app.rb
@@ -228,8 +228,8 @@ module Appsignal
         return unless active?
 
         unless error.is_a?(Exception)
-          logger.error "Appsignal.send_error: Cannot send error. The given " \
-            "value is not an exception: #{error.inspect}"
+          internal_logger.error "Appsignal.send_error: Cannot send error. " \
+            "The given value is not an exception: #{error.inspect}"
           return
         end
         transaction = Appsignal::Transaction.new(
@@ -319,8 +319,8 @@ module Appsignal
               "Appsignal.set_error called on location: #{call_location}"
         end
         unless exception.is_a?(Exception)
-          logger.error "Appsignal.set_error: Cannot set error. The given " \
-            "value is not an exception: #{exception.inspect}"
+          internal_logger.error "Appsignal.set_error: Cannot set error. " \
+            "The given value is not an exception: #{exception.inspect}"
           return
         end
         return if !active? || !Appsignal::Transaction.current?

data/lib/appsignal/helpers/metrics.rb

@@ -10,22 +10,24 @@ module Appsignal
           Appsignal::Utils::Data.generate(tags)
         )
       rescue RangeError
-        Appsignal.logger
+        Appsignal.internal_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")
+      def set_host_gauge(_key, _value)
+        Appsignal::Utils::DeprecationMessage.message \
+          "The `set_host_gauge` method has been deprecated. " \
+            "Calling this method has no effect. " \
+            "Please remove method call in the following file to remove " \
+            "this message.\n#{caller.first}"
       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")
+      def set_process_gauge(_key, _value)
+        Appsignal::Utils::DeprecationMessage.message \
+          "The `set_process_gauge` method has been deprecated. " \
+            "Calling this method has no effect. " \
+            "Please remove method call in the following file to remove " \
+            "this message.\n#{caller.first}"
       end
 
       def increment_counter(key, value = 1.0, tags = {})
@@ -35,7 +37,7 @@ module Appsignal
           Appsignal::Utils::Data.generate(tags)
         )
       rescue RangeError
-        Appsignal.logger
+        Appsignal.internal_logger
           .warn("Counter value #{value} for key '#{key}' is too big")
       end
 
@@ -46,7 +48,7 @@ module Appsignal
           Appsignal::Utils::Data.generate(tags)
         )
       rescue RangeError
-        Appsignal.logger
+        Appsignal.internal_logger
           .warn("Distribution value #{value} for key '#{key}' is too big")
       end
     end

data/lib/appsignal/hooks/active_job.rb

@@ -56,7 +56,7 @@ module Appsignal
           super
         rescue Exception => exception # rubocop:disable Lint/RescueException
           job_status = :failed
-          transaction.set_error(exception)
+          transaction_set_error(transaction, exception)
           raise exception
         ensure
           if transaction
@@ -82,6 +82,14 @@ module Appsignal
               tags.merge(:status => :processed)
           end
         end
+
+        private
+
+        def transaction_set_error(transaction, exception)
+          return if Appsignal.config[:activejob_report_errors] == "none"
+
+          transaction.set_error(exception)
+        end
       end
 
       module ActiveJobHelpers

data/lib/appsignal/hooks/active_support_notifications.rb

@@ -22,21 +22,30 @@ module Appsignal
         end
 
         require "appsignal/integrations/active_support_notifications"
-        instrumenter = ::ActiveSupport::Notifications::Instrumenter
         parent_integration_module = Appsignal::Integrations::ActiveSupportNotificationsIntegration
-        if instrumenter.method_defined?(:start) && instrumenter.method_defined?(:finish)
-          install_module(parent_integration_module::StartFinishIntegration)
+
+        if defined?(::ActiveSupport::Notifications::Fanout::Handle)
+          install_module(
+            parent_integration_module::StartFinishHandlerIntegration,
+            ::ActiveSupport::Notifications::Fanout::Handle
+          )
         else
-          install_module(parent_integration_module::InstrumentIntegration)
-        end
+          instrumenter = ::ActiveSupport::Notifications::Instrumenter
 
-        return unless instrumenter.method_defined?(:finish_with_state)
+          if instrumenter.method_defined?(:start) && instrumenter.method_defined?(:finish)
+            install_module(parent_integration_module::StartFinishIntegration, instrumenter)
+          else
+            install_module(parent_integration_module::InstrumentIntegration, instrumenter)
+          end
 
-        install_module(parent_integration_module::FinishStateIntegration)
+          return unless instrumenter.method_defined?(:finish_with_state)
+
+          install_module(parent_integration_module::FinishStateIntegration, instrumenter)
+        end
       end
 
-      def install_module(mod)
-        ::ActiveSupport::Notifications::Instrumenter.send(:prepend, mod)
+      def install_module(mod, instrumenter)
+        instrumenter.send(:prepend, mod)
       end
     end
   end

data/lib/appsignal/hooks/dry_monitor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Hooks
+    # @api private
+    class DryMonitorHook < Appsignal::Hooks::Hook
+      register :dry_monitor
+
+      def dependencies_present?
+        defined?(::Dry::Monitor::Notifications)
+      end
+
+      def install
+        require "appsignal/integrations/dry_monitor"
+
+        ::Dry::Monitor::Notifications.prepend(Appsignal::Integrations::DryMonitorIntegration)
+      end
+    end
+  end
+end

data/lib/appsignal/hooks/redis.rb

@@ -8,6 +8,7 @@ module Appsignal
 
       def dependencies_present?
         defined?(::Redis) &&
+          !defined?(::RedisClient) &&
           Appsignal.config &&
           Appsignal.config[:instrument_redis]
       end

data/lib/appsignal/hooks/redis_client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Hooks
+    # @api private
+    class RedisClientHook < Appsignal::Hooks::Hook
+      register :redis_client
+
+      def dependencies_present?
+        defined?(::RedisClient) &&
+          Gem::Version.new(::RedisClient::VERSION) >= Gem::Version.new("0.14.0") &&
+          Appsignal.config &&
+          Appsignal.config[:instrument_redis]
+      end
+
+      def install
+        require "appsignal/integrations/redis_client"
+        ::RedisClient::RubyConnection.prepend Appsignal::Integrations::RedisClientIntegration
+        Appsignal::Environment.report_enabled("redis")
+
+        return unless defined?(::RedisClient::HiredisConnection)
+
+        ::RedisClient::HiredisConnection.prepend Appsignal::Integrations::RedisClientIntegration
+        Appsignal::Environment.report_enabled("hiredis")
+      end
+    end
+  end
+end

data/lib/appsignal/hooks.rb

@@ -32,12 +32,12 @@ module Appsignal
         return unless dependencies_present?
         return if installed?
 
-        Appsignal.logger.debug("Installing #{name} hook")
+        Appsignal.internal_logger.debug("Installing #{name} hook")
         begin
           install
           @installed = true
         rescue => ex
-          logger = Appsignal.logger
+          logger = Appsignal.internal_logger
           logger.error("Error while installing #{name} hook: #{ex}")
           logger.debug ex.backtrace.join("\n")
         end
@@ -95,6 +95,7 @@ require "appsignal/hooks/active_support_notifications"
 require "appsignal/hooks/celluloid"
 require "appsignal/hooks/delayed_job"
 require "appsignal/hooks/gvl"
+require "appsignal/hooks/dry_monitor"
 require "appsignal/hooks/http"
 require "appsignal/hooks/mri"
 require "appsignal/hooks/net_http"
@@ -102,6 +103,7 @@ require "appsignal/hooks/passenger"
 require "appsignal/hooks/puma"
 require "appsignal/hooks/rake"
 require "appsignal/hooks/redis"
+require "appsignal/hooks/redis_client"
 require "appsignal/hooks/resque"
 require "appsignal/hooks/sequel"
 require "appsignal/hooks/shoryuken"

data/lib/appsignal/integrations/active_support_notifications.rb

@@ -54,6 +54,32 @@ module Appsignal
         end
       end
 
+      module StartFinishHandlerIntegration
+        def start
+          instrument_this = @name[0] != ActiveSupportNotificationsIntegration::BANG
+
+          Appsignal::Transaction.current.start_event if instrument_this
+          super
+        end
+
+        def finish_with_values(name, id, payload = {})
+          # Events that start with a bang are internal to Rails
+          instrument_this = name[0] != ActiveSupportNotificationsIntegration::BANG
+
+          if instrument_this
+            title, body, body_format = Appsignal::EventFormatter.format(name, payload)
+            Appsignal::Transaction.current.finish_event(
+              name.to_s,
+              title,
+              body,
+              body_format
+            )
+          end
+
+          super
+        end
+      end
+
       module FinishStateIntegration
         def finish_with_state(listeners_state, name, payload = {})
           # Events that start with a bang are internal to Rails

data/lib/appsignal/integrations/dry_monitor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    module DryMonitorIntegration
+      def instrument(event_id, payload = {}, &block)
+        Appsignal::Transaction.current.start_event
+
+        super
+      ensure
+        title, body, body_format = Appsignal::EventFormatter.format("#{event_id}.dry", payload)
+
+        Appsignal::Transaction.current.finish_event(
+          title || event_id.to_s,
+          title,
+          body,
+          body_format
+        )
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/hanami.rb

@@ -6,7 +6,7 @@ module Appsignal
   module Integrations
     module HanamiPlugin
       def self.init
-        Appsignal.logger.debug("Loading Hanami integration")
+        Appsignal.internal_logger.debug("Loading Hanami integration")
 
         hanami_app_config = ::Hanami.app.config
         Appsignal.config = Appsignal::Config.new(

data/lib/appsignal/integrations/padrino.rb

@@ -7,7 +7,7 @@ module Appsignal
     # @api private
     module PadrinoPlugin
       def self.init
-        Appsignal.logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
+        Appsignal.internal_logger.debug("Loading Padrino (#{Padrino::VERSION}) integration")
 
         root = Padrino.mounted_root
         Appsignal.config = Appsignal::Config.new(root, Padrino.env)