appsignal 3.12.6 → 4.0.0.beta.1

data/lib/appsignal/check_in/cron.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module CheckIn
+    class Cron
+      class << self
+        # @api private
+        def transmitter
+          @transmitter ||= Appsignal::Transmitter.new(
+            "#{Appsignal.config[:logging_endpoint]}/check_ins/json"
+          )
+        end
+      end
+
+      # @api private
+      attr_reader :identifier, :digest
+
+      def initialize(identifier:)
+        @identifier = identifier
+        @digest = SecureRandom.hex(8)
+      end
+
+      def start
+        transmit_event("start")
+      end
+
+      def finish
+        transmit_event("finish")
+      end
+
+      private
+
+      def event(kind)
+        {
+          :identifier => @identifier,
+          :digest => @digest,
+          :kind => kind,
+          :timestamp => Time.now.utc.to_i,
+          :check_in_type => "cron"
+        }
+      end
+
+      def transmit_event(kind)
+        unless Appsignal.active?
+          Appsignal.internal_logger.debug(
+            "AppSignal not active, not transmitting cron check-in event"
+          )
+          return
+        end
+
+        response = self.class.transmitter.transmit(event(kind))
+
+        if response.code.to_i >= 200 && response.code.to_i < 300
+          Appsignal.internal_logger.debug(
+            "Transmitted cron check-in `#{identifier}` (#{digest}) #{kind} event"
+          )
+        else
+          Appsignal.internal_logger.error(
+            "Failed to transmit cron check-in #{kind} event: status code was #{response.code}"
+          )
+        end
+      rescue => e
+        Appsignal.internal_logger.error("Failed to transmit cron check-in #{kind} event: #{e}")
+      end
+    end
+  end
+end

data/lib/appsignal/check_in.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module CheckIn
+    class << self
+      # Track cron check-ins.
+      #
+      # Track the execution of certain processes by sending a cron check-in.
+      #
+      # To track the duration of a piece of code, pass a block to {.cron}
+      # to report both when the process starts, and when it finishes.
+      #
+      # If an exception is raised within the block, the finish event will not
+      # be reported, triggering a notification about the missing cron check-in.
+      # The exception will bubble outside of the cron check-in block.
+      #
+      # @example Send a cron check-in
+      #   Appsignal::CheckIn.cron("send_invoices")
+      #
+      # @example Send a cron check-in with duration
+      #   Appsignal::CheckIn.cron("send_invoices") do
+      #     # your code
+      #   end
+      #
+      # @param name [String] name of the cron check-in to report.
+      # @yield the block to monitor.
+      # @return [void]
+      # @since 3.13.0
+      # @see https://docs.appsignal.com/check-ins/cron
+      def cron(identifier)
+        cron = Appsignal::CheckIn::Cron.new(:identifier => identifier)
+        output = nil
+
+        if block_given?
+          cron.start
+          output = yield
+        end
+
+        cron.finish
+        output
+      end
+    end
+  end
+end
+
+require "appsignal/check_in/cron"

data/lib/appsignal/cli/diagnose.rb

@@ -77,6 +77,10 @@ module Appsignal
         # @return [void]
         # @api private
         def run(options = {})
+          # Do not start AppSignal on `Appsignal.start` and run the extension
+          # and agent in diagnose mode.
+          ENV["_APPSIGNAL_DIAGNOSE"] = "true"
+
           self.coloring = options.delete(:color) { true }
           $stdout.sync = true
           header
@@ -184,21 +188,13 @@ module Appsignal
         end
 
         def configure_appsignal(options)
-          current_path = Dir.pwd
-          initial_config = {}
-          if rails_app?
-            data[:app][:rails] = true
-            current_path = Rails.root
-            initial_config[:name] =
-              Appsignal::Utils::RailsHelper.detected_rails_app_name
-            initial_config[:log_path] = current_path.join("log")
-          end
+          # Try and load the Rails app, if any.
+          # This will configure AppSignal through the config file or an
+          # initializer.
+          require_rails_app_if_present
 
-          Appsignal._config = Appsignal::Config.new(
-            current_path,
-            options.fetch(:environment, ENV.fetch("RACK_ENV", ENV.fetch("RAILS_ENV", nil))),
-            initial_config
-          )
+          # If no config was found by loading the app, load with the defaults.
+          Appsignal.configure(options.fetch(:environment, nil))
           Appsignal.config.write_to_environment
           Appsignal._start_logger
           Appsignal.internal_logger.info("Starting AppSignal diagnose")
@@ -211,9 +207,9 @@ module Appsignal
             return
           end
 
-          ENV["_APPSIGNAL_DIAGNOSE"] = "true"
+          # Requires _APPSIGNAL_DIAGNOSE to be set. This is set at the
+          # beginning of the diagnose CLI.
           diagnostics_report_string = Appsignal::Extension.diagnose
-          ENV.delete("_APPSIGNAL_DIAGNOSE")
 
           begin
             report = JSON.parse(diagnostics_report_string)
@@ -473,14 +469,12 @@ module Appsignal
             :sources => {
               :default => Appsignal::Config::DEFAULT_CONFIG,
               :system => config.system_config,
+              :loaders => config.loaders_config,
               :initial => config.initial_config,
               :file => config.file_config,
               :env => config.env_config,
-              :override => config.override_config
-            },
-            :modifiers => {
-              "APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR" =>
-                ENV.fetch("APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR", "")
+              :override => config.override_config,
+              :dsl => config.dsl_config
             }
           }
           print_config_options(config)
@@ -523,11 +517,6 @@ module Appsignal
             end
           end
 
-          puts
-          puts "Configuration modifiers"
-          puts "  APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR: " \
-            "#{data[:config][:modifiers]["APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR"].inspect}"
-
           puts "\nRead more about how the diagnose config output is rendered\n" \
             "https://docs.appsignal.com/ruby/command-line/diagnose.html"
         end
@@ -642,9 +631,29 @@ module Appsignal
           puts "\n"
         end
 
-        def rails_app?
+        def require_rails_app_if_present
+          return unless rails_present?
+
+          # Mark app as Rails app
+          data[:app][:rails] = true
+          # Manually require the railtie, because it wasn't loaded when the CLI
+          # started and AppSignal loaded, because the `Rails` constant wasn't
+          # present.
+          require "appsignal/integrations/railtie"
+          # Start the Rails app, including railties and initializers.
+          require Appsignal::Utils::RailsHelper.environment_config_path
+        rescue LoadError, StandardError => error
+          print_empty_line
+          puts "ERROR: Error encountered while loading the Rails app"
+          puts "#{error.class}: #{error.message}"
+          puts error.backtrace
+          data[:app][:load_error] =
+            "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+        end
+
+        def rails_present?
+          # Try and load the Rails gem
           require "rails"
-          require File.expand_path(File.join(Dir.pwd, "config", "application.rb"))
           true
         rescue LoadError
           false

data/lib/appsignal/cli/install.rb

@@ -237,6 +237,10 @@ module Appsignal
           puts "How do you want to configure AppSignal?"
           puts "  (1) a config file"
           puts "  (2) environment variables"
+          puts
+          puts "  See our docs for information on the different configuration methods: "
+          puts "  https://docs.appsignal.com/ruby/configuration.html"
+          puts
           loop do
             print "  Choose (1/2): "
             case ask_for_input
@@ -264,7 +268,7 @@ module Appsignal
               puts "  export APPSIGNAL_APP_NAME=#{config[:name]}" if name_overwritten
               puts
               puts "  See the documentation for more configuration options:"
-              puts "  https://docs.appsignal.com/gem-settings/configuration.html"
+              puts "  https://docs.appsignal.com/ruby/configuration.html"
               press_any_key
               break
             end

data/lib/appsignal/config.rb

@@ -8,16 +8,19 @@ require "tmpdir"
 
 module Appsignal
   class Config
-    include Appsignal::Utils::StdoutAndLoggerMessage
-
     # @api private
     def self.loader_defaults
       @loader_defaults ||= []
     end
 
     # @api private
-    def self.add_loader_defaults(name, options)
-      loader_defaults << [name, options]
+    def self.add_loader_defaults(name, env: nil, root_path: nil, **options)
+      loader_defaults << {
+        :name => name,
+        :env => env,
+        :root_path => root_path,
+        :options => options.compact
+      }
     end
 
     # Determine which env AppSignal should initialize with.
@@ -32,7 +35,7 @@ module Appsignal
         return env if env
       end
 
-      loader_defaults.reverse.each do |(_loader_name, loader_defaults)|
+      loader_defaults.reverse.each do |loader_defaults|
         env = loader_defaults[:env]
         return env if env
       end
@@ -43,7 +46,7 @@ module Appsignal
     # Determine which root path AppSignal should initialize with.
     # @api private
     def self.determine_root_path
-      loader_defaults.reverse.each do |(_loader_name, loader_defaults)|
+      loader_defaults.reverse.each do |loader_defaults|
         root_path = loader_defaults[:root_path]
         return root_path if root_path
       end
@@ -55,9 +58,9 @@ module Appsignal
     DEFAULT_CONFIG = {
       :activejob_report_errors => "all",
       :ca_file_path => File.expand_path(File.join("../../../resources/cacert.pem"), __FILE__),
-      :debug => false,
       :dns_servers => [],
       :enable_allocation_tracking => true,
+      :enable_at_exit_reporter => true,
       :enable_host_metrics => true,
       :enable_minutely_probes => true,
       :enable_statsd => true,
@@ -90,8 +93,8 @@ module Appsignal
       ],
       :send_environment_metadata => true,
       :send_params => true,
-      :sidekiq_report_errors => "all",
-      :transaction_debug_mode => false
+      :send_session_data => true,
+      :sidekiq_report_errors => "all"
     }.freeze
 
     # @api private
@@ -127,14 +130,13 @@ module Appsignal
       "APPSIGNAL_SIDEKIQ_REPORT_ERRORS" => :sidekiq_report_errors,
       "APPSIGNAL_STATSD_PORT" => :statsd_port,
       "APPSIGNAL_WORKING_DIRECTORY_PATH" => :working_directory_path,
-      "APPSIGNAL_WORKING_DIR_PATH" => :working_dir_path,
       "APP_REVISION" => :revision
     }.freeze
     # @api private
     ENV_BOOLEAN_KEYS = {
       "APPSIGNAL_ACTIVE" => :active,
-      "APPSIGNAL_DEBUG" => :debug,
       "APPSIGNAL_ENABLE_ALLOCATION_TRACKING" => :enable_allocation_tracking,
+      "APPSIGNAL_ENABLE_AT_EXIT_REPORTER" => :enable_at_exit_reporter,
       "APPSIGNAL_ENABLE_HOST_METRICS" => :enable_host_metrics,
       "APPSIGNAL_ENABLE_MINUTELY_PROBES" => :enable_minutely_probes,
       "APPSIGNAL_ENABLE_STATSD" => :enable_statsd,
@@ -152,9 +154,7 @@ module Appsignal
       "APPSIGNAL_RUNNING_IN_CONTAINER" => :running_in_container,
       "APPSIGNAL_SEND_ENVIRONMENT_METADATA" => :send_environment_metadata,
       "APPSIGNAL_SEND_PARAMS" => :send_params,
-      "APPSIGNAL_SEND_SESSION_DATA" => :send_session_data,
-      "APPSIGNAL_SKIP_SESSION_DATA" => :skip_session_data,
-      "APPSIGNAL_TRANSACTION_DEBUG_MODE" => :transaction_debug_mode
+      "APPSIGNAL_SEND_SESSION_DATA" => :send_session_data
     }.freeze
     # @api private
     ENV_ARRAY_KEYS = {
@@ -178,11 +178,6 @@ module Appsignal
     #   Used in diagnose report.
     #   @api private
     #   @return [Hash]
-    # @!attribute [r] initial_config
-    #   Config detected on the system level.
-    #   Used in diagnose report.
-    #   @api private
-    #   @return [Hash]
     # @!attribute [r] file_config
     #   Config loaded from `config/appsignal.yml` config file.
     #   Used in diagnose report.
@@ -195,8 +190,8 @@ module Appsignal
     #   @return [Hash]
     # @!attribute [r] config_hash
     #   Config used by the AppSignal gem.
-    #   Combined Hash of the {system_config}, {initial_config}, {file_config},
-    #   {env_config} attributes.
+    #   Combined Hash of the {system_config}, {file_config}, {env_config}
+    #   attributes.
     #   @see #[]
     #   @see #[]=
     #   @api private
@@ -204,8 +199,8 @@ module Appsignal
 
     # @api private
     attr_accessor :root_path, :env, :config_hash
-    attr_reader :system_config, :initial_config, :file_config, :env_config,
-      :override_config, :dsl_config
+    attr_reader :system_config, :loaders_config, :initial_config, :file_config,
+      :env_config, :override_config, :dsl_config
     # @api private
     attr_accessor :logger
 
@@ -215,9 +210,6 @@ module Appsignal
     # @param initial_env [String] The environment to load when AppSignal is started. It
     #   will look for an environment with this name in the `config/appsignal.yml`
     #   config file.
-    # @param initial_config [Hash<String, Object>] The initial configuration to
-    #   use. This will be overwritten by the file config and environment
-    #   variables config.
     # @param logger [Logger] The logger to use for the AppSignal gem. This is
     #   used by the configuration class only. Default:
     #   {Appsignal.internal_logger}. See also {Appsignal.start}.
@@ -231,13 +223,10 @@ module Appsignal
     #   Configuration load order
     # @see https://docs.appsignal.com/ruby/instrumentation/integrating-appsignal.html
     #   How to integrate AppSignal manually
-    def initialize( # rubocop:disable Metrics/ParameterLists
+    def initialize(
       root_path,
       initial_env,
-      initial_config = {},
-      logger = Appsignal.internal_logger,
-      config_file = nil,
-      load_on_new = true # rubocop:disable Style/OptionalBooleanParameter
+      logger = Appsignal.internal_logger
     )
       @root_path = root_path
       @config_file_error = false
@@ -249,20 +238,14 @@ module Appsignal
       @env = initial_env.to_s
       @config_hash = {}
       @system_config = {}
-      @initial_config = initial_config
+      @loaders_config = {}
+      @initial_config = {}
       @file_config = {}
       @env_config = {}
       @override_config = {}
       @dsl_config = {} # Can be set using `Appsignal.configure`
 
-      return unless load_on_new
-
-      # Always override environment if set via this env var.
-      # TODO: This is legacy behavior. In the `Appsignal.configure` method the
-      # env argument is leading.
-      @env = ENV["APPSIGNAL_APP_ENV"] if ENV.key?("APPSIGNAL_APP_ENV")
       load_config
-      validate
     end
 
     # @api private
@@ -275,8 +258,17 @@ module Appsignal
       @system_config = detect_from_system
       merge(system_config)
 
-      # Merge initial config
-      merge(initial_config)
+      # Set defaults from loaders in reverse order so the first register
+      # loader's defaults overwrite all others
+      self.class.loader_defaults.reverse.each do |loader_defaults|
+        defaults = loader_defaults[:options]
+        @loaders_config.merge!(defaults.merge(
+          :root_path => loader_defaults[:root_path],
+          :env => loader_defaults[:env]
+        ))
+        merge(defaults)
+      end
+
       # Track origin of env
       @initial_config[:env] = @initial_env.to_s
 
@@ -290,13 +282,6 @@ module Appsignal
       # Track origin of env
       env_loaded_from_env = ENV.fetch("APPSIGNAL_APP_ENV", nil)
       @env_config[:env] = env_loaded_from_env if env_loaded_from_env
-
-      # Load config overrides
-      @override_config = determine_overrides
-      merge(override_config)
-
-      # Handle deprecated config options
-      maintain_backwards_compatibility
     end
 
     # @api private
@@ -326,12 +311,12 @@ module Appsignal
 
     # @api private
     def log_level
-      level = ::Logger::DEBUG if config_hash[:debug] || config_hash[:transaction_debug_mode]
       option = config_hash[:log_level]
-      if option
-        log_level_option = LOG_LEVEL_MAP[option]
-        level = log_level_option if log_level_option
-      end
+      level =
+        if option
+          log_level_option = LOG_LEVEL_MAP[option]
+          log_level_option
+        end
       level.nil? ? Appsignal::Config::DEFAULT_LOG_LEVEL : level
     end
 
@@ -379,7 +364,6 @@ module Appsignal
       ENV["_APPSIGNAL_BIND_ADDRESS"]                 = config_hash[:bind_address].to_s
       ENV["_APPSIGNAL_CA_FILE_PATH"]                 = config_hash[:ca_file_path].to_s
       ENV["_APPSIGNAL_CPU_COUNT"]                    = config_hash[:cpu_count].to_s
-      ENV["_APPSIGNAL_DEBUG_LOGGING"]                = config_hash[:debug].to_s
       ENV["_APPSIGNAL_DNS_SERVERS"]                  = config_hash[:dns_servers].join(",")
       ENV["_APPSIGNAL_ENABLE_HOST_METRICS"]          = config_hash[:enable_host_metrics].to_s
       ENV["_APPSIGNAL_ENABLE_STATSD"]                = config_hash[:enable_statsd].to_s
@@ -406,24 +390,24 @@ 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_TRANSACTION_DEBUG_MODE"]       = config_hash[:transaction_debug_mode].to_s
       if config_hash[:working_directory_path]
         ENV["_APPSIGNAL_WORKING_DIRECTORY_PATH"] = config_hash[:working_directory_path]
       end
-      if config_hash[:working_dir_path]
-        ENV["_APPSIGNAL_WORKING_DIR_PATH"] = config_hash[:working_dir_path]
-      end
       ENV["_APP_REVISION"] = config_hash[:revision].to_s
     end
 
     # @api private
     def merge_dsl_options(options)
-      @dsl_options = options
+      @dsl_config = options
       merge(options)
     end
 
     # @api private
     def validate
+      # Apply any overrides for invalid settings.
+      @override_config = determine_overrides
+      merge(override_config)
+
       # Strip path from endpoint so we're backwards compatible with
       # earlier versions of the gem.
       # TODO: Move to its own method, maybe in `#[]=`?
@@ -444,6 +428,17 @@ module Appsignal
       end
     end
 
+    # Deep freeze the config object so it cannot be modified during the runtime
+    # of the Ruby app.
+    #
+    # @api private
+    # @since 4.0.0
+    def freeze
+      super
+      config_hash.freeze
+      config_hash.transform_values(&:freeze)
+    end
+
     private
 
     def config_file
@@ -475,20 +470,9 @@ module Appsignal
         nil
       end
     rescue => e
-      # TODO: Remove in the next major version
       @config_file_error = true
-      extra_message =
-        if inactive_on_config_file_error?
-          "Not starting AppSignal because " \
-            "APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR is set."
-        else
-          "Skipping file config. In future versions AppSignal will not start " \
-            "on a config file error. To opt-in to this new behavior set " \
-            "'APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR=1' in your system " \
-            "environment."
-        end
       message = "An error occurred while loading the AppSignal config file. " \
-        "#{extra_message}\n" \
+        "Not starting AppSignal.\n" \
         "File: #{config_file.inspect}\n" \
         "#{e.class.name}: #{e}"
       Kernel.warn "appsignal: #{message}"
@@ -496,27 +480,6 @@ module Appsignal
       nil
     end
 
-    # Maintain backwards compatibility with deprecated config options.
-    #
-    # Add warnings for deprecated config options here if they have no
-    # replacement, or should be non-functional.
-    #
-    # Add them to {determine_overrides} if replacement config options should be
-    # set instead.
-    #
-    # Make sure to remove the contents of this method in the next major
-    # version, but the method itself with an empty body can stick around as a
-    # structure for future deprecations.
-    def maintain_backwards_compatibility
-      return unless config_hash.key?(:working_dir_path)
-
-      stdout_and_logger_warning \
-        "The `working_dir_path` option is deprecated, please use " \
-          "`working_directory_path` instead and specify the " \
-          "full path to the working directory",
-        logger
-    end
-
     def load_from_environment
       config = {}
 
@@ -556,32 +519,13 @@ module Appsignal
     end
 
     # Set config options based on the final user config. Fix any conflicting
-    # config or set new config options based on deprecated config options.
-    #
-    # Make sure to remove behavior for deprecated config options in this method
-    # in the next major version, but the method itself with an empty body can
-    # stick around as a structure for future deprecations.
+    # config.
     def determine_overrides
       config = {}
       # 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.
-      # TODO: Make default behavior in next major version. Remove
-      # `inactive_on_config_file_error?` call.
-      config[:active] = false if @config_file_error && inactive_on_config_file_error?
-      skip_session_data = config_hash[:skip_session_data]
-      send_session_data = config_hash[:send_session_data]
-      if skip_session_data.nil? # Deprecated option is not set
-        if send_session_data.nil? # Not configured by user
-          config[:send_session_data] = true # Set default value
-        end
-      else
-        stdout_and_logger_warning "The `skip_session_data` config option is " \
-          "deprecated. Please use `send_session_data` instead.",
-          logger
-        # Not configured by user
-        config[:send_session_data] = !skip_session_data if send_session_data.nil?
-      end
+      config[:active] = false if @config_file_error
 
       if config_hash[:activejob_report_errors] == "discard" &&
           !Appsignal::Hooks::ActiveJobHook.version_7_1_or_higher?
@@ -603,12 +547,6 @@ module Appsignal
       end
     end
 
-    # Does it use the new behavior?
-    def inactive_on_config_file_error?
-      value = ENV.fetch("APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR", false)
-      ["1", "true"].include?(value)
-    end
-
     # @api private
     class ConfigDSL
       attr_reader :dsl_options

data/lib/appsignal/demo.rb

@@ -70,14 +70,14 @@ module Appsignal
       end
 
       def add_params_to(transaction)
-        transaction.set_params(
+        transaction.add_params(
           "controller" => "demo",
           "action" => "hello"
         )
       end
 
       def add_headers_to(transaction)
-        transaction.set_headers(
+        transaction.add_headers(
           "REMOTE_ADDR" => "127.0.0.1",
           "REQUEST_METHOD" => "GET",
           "SERVER_NAME" => "localhost",

data/lib/appsignal/extension/jruby.rb

@@ -132,6 +132,9 @@ module Appsignal
         attach_function :appsignal_complete_transaction,
           [:pointer],
           :void
+        attach_function :appsignal_duplicate_transaction,
+          [:pointer, :appsignal_string],
+          :pointer
         attach_function :appsignal_transaction_to_json,
           [:pointer],
           :appsignal_string
@@ -432,6 +435,17 @@ module Appsignal
           Extension.appsignal_finish_transaction(pointer, gc_duration_ms)
         end
 
+        def duplicate(new_transaction_id)
+          duplicate_transaction = Extension.appsignal_duplicate_transaction(
+            pointer,
+            make_appsignal_string(new_transaction_id)
+          )
+
+          return if !duplicate_transaction || duplicate_transaction.null?
+
+          Transaction.new(duplicate_transaction)
+        end
+
         def complete
           Extension.appsignal_complete_transaction(pointer)
         end