appsignal 4.2.0 → 4.5.17

data/lib/appsignal/config.rb

@@ -39,8 +39,10 @@ module Appsignal
         ENV.fetch("APPSIGNAL_APP_ENV", nil),
         ENV.fetch("RAILS_ENV", nil),
         ENV.fetch("RACK_ENV", nil)
-      ].compact.each do |env|
-        return env if env
+      ].compact.each do |env_value|
+        value = env_value.to_s.strip
+        next if value.empty?
+        return value if value
       end
 
       loader_defaults.reverse.each do |loader_defaults|
@@ -91,6 +93,7 @@ module Appsignal
       :ca_file_path => File.expand_path(File.join("../../../resources/cacert.pem"), __FILE__),
       :dns_servers => [],
       :enable_allocation_tracking => true,
+      :enable_at_exit_hook => "on_error",
       :enable_at_exit_reporter => true,
       :enable_host_metrics => true,
       :enable_minutely_probes => true,
@@ -111,10 +114,12 @@ module Appsignal
       :ignore_namespaces => [],
       :instrument_http_rb => true,
       :instrument_net_http => true,
+      :instrument_ownership => true,
       :instrument_redis => true,
       :instrument_sequel => true,
       :log => "file",
       :logging_endpoint => "https://appsignal-endpoint.net",
+      :ownership_set_namespace => false,
       :request_headers => %w[
         HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
         HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_CONNECTION
@@ -149,6 +154,7 @@ module Appsignal
       :name => "APPSIGNAL_APP_NAME",
       :bind_address => "APPSIGNAL_BIND_ADDRESS",
       :ca_file_path => "APPSIGNAL_CA_FILE_PATH",
+      :enable_at_exit_hook => "APPSIGNAL_ENABLE_AT_EXIT_HOOK",
       :hostname => "APPSIGNAL_HOSTNAME",
       :host_role => "APPSIGNAL_HOST_ROLE",
       :http_proxy => "APPSIGNAL_HTTP_PROXY",
@@ -160,6 +166,7 @@ module Appsignal
       :push_api_key => "APPSIGNAL_PUSH_API_KEY",
       :sidekiq_report_errors => "APPSIGNAL_SIDEKIQ_REPORT_ERRORS",
       :statsd_port => "APPSIGNAL_STATSD_PORT",
+      :nginx_port => "APPSIGNAL_NGINX_PORT",
       :working_directory_path => "APPSIGNAL_WORKING_DIRECTORY_PATH",
       :revision => "APP_REVISION"
     }.freeze
@@ -181,8 +188,10 @@ module Appsignal
       :files_world_accessible => "APPSIGNAL_FILES_WORLD_ACCESSIBLE",
       :instrument_http_rb => "APPSIGNAL_INSTRUMENT_HTTP_RB",
       :instrument_net_http => "APPSIGNAL_INSTRUMENT_NET_HTTP",
+      :instrument_ownership => "APPSIGNAL_INSTRUMENT_OWNERSHIP",
       :instrument_redis => "APPSIGNAL_INSTRUMENT_REDIS",
       :instrument_sequel => "APPSIGNAL_INSTRUMENT_SEQUEL",
+      :ownership_set_namespace => "APPSIGNAL_OWNERSHIP_SET_NAMESPACE",
       :running_in_container => "APPSIGNAL_RUNNING_IN_CONTAINER",
       :send_environment_metadata => "APPSIGNAL_SEND_ENVIRONMENT_METADATA",
       :send_params => "APPSIGNAL_SEND_PARAMS",
@@ -242,8 +251,8 @@ module Appsignal
     )
       @load_yaml_file = load_yaml_file
       @root_path = root_path.to_s
-      @config_file_error = false
-      @config_file = config_file
+      @yml_config_file_error = false
+      @yml_config_file = yml_config_file
       @valid = false
 
       @env = env.to_s
@@ -385,8 +394,12 @@ module Appsignal
       @valid
     end
 
+    def active_for_env?
+      config_hash[:active]
+    end
+
     def active?
-      @valid && config_hash[:active]
+      valid? && active_for_env?
     end
 
     # @api private
@@ -424,6 +437,7 @@ module Appsignal
       ENV["_APPSIGNAL_RUNNING_IN_CONTAINER"]         = config_hash[:running_in_container].to_s
       ENV["_APPSIGNAL_SEND_ENVIRONMENT_METADATA"]    = config_hash[:send_environment_metadata].to_s
       ENV["_APPSIGNAL_STATSD_PORT"]                  = config_hash[:statsd_port].to_s
+      ENV["_APPSIGNAL_NGINX_PORT"]                   = config_hash[:nginx_port].to_s
       if config_hash[:working_directory_path]
         ENV["_APPSIGNAL_WORKING_DIRECTORY_PATH"] = config_hash[:working_directory_path]
       end
@@ -436,12 +450,16 @@ module Appsignal
       merge(options)
     end
 
+    # Apply any overrides for invalid settings.
     # @api private
-    def validate
-      # Apply any overrides for invalid settings.
+    def apply_overrides
       @override_config = determine_overrides
       merge(override_config)
+    end
 
+    # @return [void]
+    # @api private
+    def validate
       # Strip path from endpoint so we're backwards compatible with
       # earlier versions of the gem.
       # TODO: Move to its own method, maybe in `#[]=`?
@@ -466,6 +484,7 @@ module Appsignal
     # of the Ruby app.
     #
     # @api private
+    # @return [void]
     # @since 4.0.0
     def freeze
       super
@@ -475,9 +494,9 @@ module Appsignal
 
     # @api private
     def yml_config_file?
-      return false unless config_file
+      return false unless yml_config_file
 
-      File.exist?(config_file)
+      File.exist?(yml_config_file)
     end
 
     private
@@ -486,8 +505,8 @@ module Appsignal
       Appsignal.internal_logger
     end
 
-    def config_file
-      @config_file ||=
+    def yml_config_file
+      @yml_config_file ||=
         root_path.nil? ? nil : File.join(root_path, "config", "appsignal.yml")
     end
 
@@ -499,6 +518,8 @@ module Appsignal
         # environment variable is present and not empty.
         env_push_api_key = ENV["APPSIGNAL_PUSH_API_KEY"] || ""
         hash[:active] = true unless env_push_api_key.strip.empty?
+
+        hash[:enable_at_exit_hook] = "always" if Appsignal::Extension.running_in_container?
       end
     end
 
@@ -506,7 +527,7 @@ module Appsignal
       return unless yml_config_file?
 
       read_options = YAML::VERSION >= "4.0.0" ? { :aliases => true } : {}
-      configurations = YAML.load(ERB.new(File.read(config_file)).result, **read_options)
+      configurations = YAML.load(ERB.new(File.read(yml_config_file)).result, **read_options)
       config_for_this_env = configurations[env]
       if config_for_this_env
         config_for_this_env.transform_keys(&:to_sym)
@@ -515,10 +536,10 @@ module Appsignal
         nil
       end
     rescue => e
-      @config_file_error = true
+      @yml_config_file_error = true
       message = "An error occurred while loading the AppSignal config file. " \
         "Not starting AppSignal.\n" \
-        "File: #{config_file.inspect}\n" \
+        "File: #{yml_config_file.inspect}\n" \
         "#{e.class.name}: #{e}"
       Kernel.warn "appsignal: #{message}"
       logger.error "#{message}\n#{e.backtrace.join("\n")}"
@@ -570,7 +591,7 @@ module Appsignal
       # If an error was detected during config file reading/parsing and the new
       # behavior is enabled to not start AppSignal on incomplete config, do not
       # start AppSignal.
-      config[:active] = false if @config_file_error
+      config[:active] = false if @yml_config_file_error
 
       if config_hash[:activejob_report_errors] == "discard" &&
           !Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?

data/lib/appsignal/custom_marker.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Appsignal
+  # Custom markers are used on AppSignal.com to indicate events in an
+  # application, to give additional context on graph timelines.
+  #
+  # This helper class will send a request to the AppSignal public endpoint to
+  # create a Custom marker for the application on AppSignal.com.
+  #
+  # @see https://docs.appsignal.com/api/public-endpoint/custom-markers.html
+  #   Public Endpoint API markers endpoint documentation
+  # @see https://docs.appsignal.com/appsignal/terminology.html#markers
+  #   Terminology: Markers
+  class CustomMarker
+    # @param icon [String] icon to use for the marker, like an emoji.
+    # @param message [String] name of the user that is creating the
+    #   marker.
+    # @param created_at [Time/String] A Ruby time object or a valid ISO8601
+    #   timestamp.
+    # @return [Boolean]
+    def self.report(
+      icon: nil,
+      message: nil,
+      created_at: nil
+    )
+      new(
+        {
+          :icon => icon,
+          :message => message,
+          :created_at => created_at.respond_to?(:iso8601) ? created_at.iso8601 : created_at
+        }.compact
+      ).transmit
+    end
+
+    # @api private
+    def initialize(marker_data)
+      @marker_data = marker_data
+    end
+
+    # @api private
+    def transmit
+      unless Appsignal.config
+        Appsignal.internal_logger.warn(
+          "Did not transmit custom marker: no AppSignal config loaded"
+        )
+        return false
+      end
+
+      transmitter = Transmitter.new(
+        "#{Appsignal.config[:logging_endpoint]}/markers",
+        Appsignal.config
+      )
+      response = transmitter.transmit(@marker_data)
+
+      if (200...300).include?(response.code.to_i)
+        Appsignal.internal_logger.info("Transmitted custom marker")
+        true
+      else
+        Appsignal.internal_logger.error(
+          "Failed to transmit custom marker: #{response.code} status code"
+        )
+        false
+      end
+    rescue => e
+      Appsignal.internal_logger.error(
+        "Failed to transmit custom marker: #{e.class}: #{e.message}\n" \
+          "#{e.backtrace}"
+      )
+      false
+    end
+  end
+end

data/lib/appsignal/environment.rb

@@ -90,6 +90,7 @@ module Appsignal
       hanami
       hiredis
       mongo_ruby_driver
+      ownership
       padrino
       passenger
       puma

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

@@ -7,17 +7,15 @@ module Appsignal
       class RenderFormatter
         BLANK = ""
 
-        attr_reader :root_path
-
-        def initialize
-          @root_path = "#{Rails.root}/"
-        end
-
         def format(payload)
           return nil unless payload[:identifier]
 
           [payload[:identifier].sub(root_path, BLANK), nil]
         end
+
+        def root_path
+          @root_path ||= "#{Rails.root}/"
+        end
       end
     end
   end

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

@@ -7,14 +7,12 @@ module Appsignal
       class RenderFormatter
         BLANK = ""
 
-        attr_reader :root_path
-
-        def initialize
-          @root_path = "#{Rails.root}/"
+        def format(payload)
+          [payload[:name], payload[:identifier].sub(root_path, BLANK)]
         end
 
-        def format(payload)
-          [payload[:name], payload[:identifier].sub(@root_path, BLANK)]
+        def root_path
+          @root_path ||= "#{Rails.root}/"
         end
       end
     end

data/lib/appsignal/helpers/instrumentation.rb

@@ -154,6 +154,11 @@ module Appsignal
       #
       # @see monitor
       def monitor_and_stop(action:, namespace: nil, &block)
+        Appsignal::Utils::StdoutAndLoggerMessage.warning \
+          "The `Appsignal.monitor_and_stop` helper is deprecated. " \
+            "Use the `Appsignal.monitor` along with our `enable_at_exit_hook` " \
+            "option instead."
+
         monitor(:namespace => namespace, :action => action, &block)
       ensure
         Appsignal.stop("monitor_and_stop")

data/lib/appsignal/hooks/active_job.rb

@@ -42,7 +42,16 @@ module Appsignal
       end
 
       module ActiveJobClassInstrumentation
-        def execute(job)
+        def execute(job) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          enqueued_at = job["enqueued_at"]
+          queue_start = Time.parse(enqueued_at) if enqueued_at
+          queue_time =
+            if queue_start
+              time_now = Time.now.utc
+              # Calculate queue time and store it as milliseconds
+              (time_now - queue_start) * 1_000
+            end
+
           job_status = nil
           has_wrapper_transaction = Appsignal::Transaction.current?
           transaction =
@@ -73,10 +82,8 @@ module Appsignal
           raise exception
         ensure
           if transaction
-            enqueued_at = job["enqueued_at"]
-            if enqueued_at # Present in Rails 6 and up
-              transaction.set_queue_start((Time.parse(enqueued_at).to_f * 1_000).to_i)
-            end
+            # Present in Rails 6 and up
+            transaction.set_queue_start((queue_start.to_f * 1_000).to_i) if queue_start
 
             unless has_wrapper_transaction
               # Only complete transaction if ActiveJob is not wrapped in
@@ -94,6 +101,15 @@ module Appsignal
             ActiveJobHelpers.increment_counter metric_name, 1,
               tags.merge(:status => :processed)
           end
+
+          queue_name = job["queue_name"]
+          if queue_time && queue_name
+            ActiveJobHelpers.add_distribution_value(
+              "queue_time",
+              queue_time,
+              :queue => queue_name
+            )
+          end
         end
 
         private
@@ -172,6 +188,10 @@ module Appsignal
         def self.increment_counter(key, value, tags = {})
           Appsignal.increment_counter "active_job_#{key}", value, tags
         end
+
+        def self.add_distribution_value(key, value, tags = {})
+          Appsignal.add_distribution_value("active_job_#{key}", value, tags)
+        end
       end
     end
   end

data/lib/appsignal/hooks/at_exit.rb

@@ -11,27 +11,41 @@ module Appsignal
       end
 
       def install
-        return unless Appsignal.config[:enable_at_exit_reporter]
-
         Kernel.at_exit(&AtExitCallback.method(:call))
       end
 
-      # Report any unhandled errors and will crash the Ruby process.
+      # Stop AppSignal before the app exists.
+      #
+      # This is the default behavior and can be customized with the
+      # `enable_at_exit_hook` option.
+      #
+      # When the `enable_at_exit_reporter` option is set to `true` (the
+      # default), it will report any unhandled errors that will crash the Ruby
+      # process.
       #
       # If this error was previously reported by any of our instrumentation,
       # the error will not also be reported here. This way we don't report an
       # error from a Rake task or instrumented script twice.
       class AtExitCallback
         def self.call
+          report_error = false
+          return unless Appsignal.config&.[](:enable_at_exit_reporter)
+
           error = $! # rubocop:disable Style/SpecialGlobalVars
           return unless error
           return if ignored_error?(error)
           return if Appsignal::Transaction.last_errors.include?(error)
 
+          report_error = true
+
           Appsignal.report_error(error) do |transaction|
             transaction.set_namespace("unhandled")
           end
-          Appsignal.stop("at_exit")
+        ensure
+          at_exit_hook = Appsignal.config&.[](:enable_at_exit_hook)
+          if at_exit_hook == "always" || (at_exit_hook == "on_error" && report_error)
+            Appsignal.stop("at_exit")
+          end
         end
 
         IGNORED_ERRORS = [

data/lib/appsignal/hooks/ownership.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class Hooks
+    # @api private
+    class OwnershipHook < Appsignal::Hooks::Hook
+      register :ownership
+
+      def dependencies_present?
+        defined?(::Ownership) &&
+          Gem::Version.new(::Ownership::VERSION) >= Gem::Version.new("0.2.0") &&
+          Appsignal.config &&
+          Appsignal.config[:instrument_ownership]
+      end
+
+      def install
+        require "appsignal/integrations/ownership"
+
+        # If a transaction is created in a code context that has an owner,
+        # set the namespace of the transaction to the owner.
+        Appsignal::Transaction.after_create <<
+          Appsignal::Integrations::OwnershipIntegrationHelper.method(:after_create)
+
+        # If an error was reported in a code context that has an owner,
+        # set the namespace of the transaction to the owner.
+        # In some circumstances, this will be more accurate than the last owner
+        # that was set for the transaction, which is what would otherwise be
+        # reported.
+        Appsignal::Transaction.before_complete <<
+          Appsignal::Integrations::OwnershipIntegrationHelper.method(:before_complete)
+
+        # If an owner is set in a code context that has an active transaction,
+        # set the namespace of the transaction to the owner.
+        unless ::Ownership.singleton_class.included_modules.include?(
+          Appsignal::Integrations::OwnershipIntegration
+        )
+          ::Ownership.singleton_class.prepend Appsignal::Integrations::OwnershipIntegration
+        end
+
+        Appsignal::Environment.report_enabled("ownership")
+      end
+    end
+  end
+end

data/lib/appsignal/hooks.rb

@@ -84,6 +84,7 @@ require "appsignal/hooks/dry_monitor"
 require "appsignal/hooks/http"
 require "appsignal/hooks/mri"
 require "appsignal/hooks/net_http"
+require "appsignal/hooks/ownership"
 require "appsignal/hooks/passenger"
 require "appsignal/hooks/puma"
 require "appsignal/hooks/rake"

data/lib/appsignal/integrations/capistrano/appsignal.cap

@@ -8,22 +8,18 @@ namespace :appsignal do
     user = fetch(:appsignal_user, ENV["USER"] || ENV.fetch("USERNAME", nil))
     revision = fetch(:appsignal_revision, fetch(:current_revision))
 
-    appsignal_config = Appsignal::Config.new(
-      Dir.pwd,
-      appsignal_env
-    ).tap do |c|
-      c.merge_dsl_options(fetch(:appsignal_config, {}))
-      c.validate
+    Appsignal._load_config!(appsignal_env) do |config|
+      config&.merge_dsl_options(fetch(:appsignal_config, {}))
     end
     Appsignal._start_logger
 
-    if appsignal_config&.active?
+    if Appsignal.config&.active?
       marker_data = {
         :revision => revision,
         :user => user
       }
 
-      marker = Appsignal::Marker.new(marker_data, appsignal_config)
+      marker = Appsignal::Marker.new(marker_data, Appsignal.config)
       # {#dry_run?} helper was added in Capistrano 3.5.0
       # https://github.com/capistrano/capistrano/commit/38d8d6d2c8485f1b5643857465b16ff01da57aff
       if respond_to?(:dry_run?) && dry_run?

data/lib/appsignal/integrations/capistrano/capistrano_2_tasks.rb

@@ -5,40 +5,37 @@ module Appsignal
     # @api private
     class Capistrano
       def self.tasks(config)
-        config.load do # rubocop:disable Metrics/BlockLength
+        config.load do
           after "deploy", "appsignal:deploy"
           after "deploy:migrations", "appsignal:deploy"
 
           namespace :appsignal do
             task :deploy do
-              env = fetch(:appsignal_env,
+              appsignal_env = fetch(:appsignal_env,
                 fetch(:stage, fetch(:rails_env, fetch(:rack_env, "production"))))
               user = fetch(:appsignal_user, ENV["USER"] || ENV.fetch("USERNAME", nil))
               revision = fetch(:appsignal_revision, fetch(:current_revision))
 
-              appsignal_config = Appsignal::Config.new(
-                ENV.fetch("PWD", nil),
-                env
-              ).tap do |c|
-                c.merge_dsl_options(fetch(:appsignal_config, {}))
-                c.validate
+              Appsignal._load_config!(appsignal_env) do |conf|
+                conf&.merge_dsl_options(fetch(:appsignal_config, {}))
               end
               Appsignal._start_logger
 
-              if appsignal_config&.active?
+              if Appsignal.config&.active?
                 marker_data = {
                   :revision => revision,
                   :user => user
                 }
 
-                marker = Marker.new(marker_data, appsignal_config)
+                marker = Marker.new(marker_data, Appsignal.config)
                 if config.dry_run
                   puts "Dry run: AppSignal deploy marker not actually sent."
                 else
                   marker.transmit
                 end
               else
-                puts "Not notifying of deploy, config is not active for environment: #{env}"
+                puts "Not notifying of deploy, config is not active for " \
+                  "environment: #{appsignal_env}"
               end
             end
           end

data/lib/appsignal/integrations/http.rb

@@ -5,7 +5,8 @@ module Appsignal
     # @api private
     module HttpIntegration
       def request(verb, uri, opts = {})
-        parsed_request_uri = uri.is_a?(URI) ? uri : URI.parse(uri.to_s)
+        uri_module = defined?(HTTP::URI) ? HTTP::URI : URI
+        parsed_request_uri = uri.is_a?(URI) ? uri : uri_module.parse(uri.to_s)
         request_uri = "#{parsed_request_uri.scheme}://#{parsed_request_uri.host}"
 
         Appsignal.instrument("request.http_rb", "#{verb.upcase} #{request_uri}") do

data/lib/appsignal/integrations/ownership.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Integrations
+    # @api private
+    module OwnershipIntegration
+      # Implement the `around_change` logic by monkey-patching the reader,
+      # instead of by using the `around_change=` writer. This allows customers
+      # to use the `around_change=` writer in their own code without
+      # accidentally overriding AppSignal's instrumentation.
+      def around_change
+        proc do |owner, block|
+          OwnershipIntegrationHelper.set(Appsignal::Transaction.current, owner)
+
+          original = super
+
+          if original
+            original.call(owner, block)
+          else
+            block.call
+          end
+        end
+      end
+    end
+
+    module OwnershipIntegrationHelper
+      class << self
+        def set(transaction, owner)
+          return if owner.nil?
+
+          transaction.add_tags(:owner => owner)
+          transaction.set_namespace(owner) if set_namespace?
+        end
+
+        def after_create(transaction)
+          set(transaction, ::Ownership.owner)
+        end
+
+        def before_complete(transaction, error)
+          set(transaction, error.owner) if error.respond_to?(:owner)
+        end
+
+        private
+
+        def set_namespace?
+          Appsignal.config && Appsignal.config[:ownership_set_namespace]
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/integrations/rake.rb

@@ -4,6 +4,16 @@ module Appsignal
   module Integrations
     # @api private
     module RakeIntegration
+      IGNORED_ERRORS = [
+        # Normal exits from the application we do not need to report
+        SystemExit,
+        SignalException
+      ].freeze
+
+      def self.ignored_error?(error)
+        IGNORED_ERRORS.include?(error.class)
+      end
+
       def execute(*args)
         transaction =
           if Appsignal.config[:enable_rake_performance_instrumentation]
@@ -16,8 +26,10 @@ module Appsignal
         end
       rescue Exception => error # rubocop:disable Lint/RescueException
         Appsignal::Integrations::RakeIntegrationHelper.register_at_exit_hook
-        transaction ||= _appsignal_create_transaction
-        transaction.set_error(error)
+        unless RakeIntegration.ignored_error?(error)
+          transaction ||= _appsignal_create_transaction
+          transaction.set_error(error)
+        end
         raise error
       ensure
         if transaction