appsignal 4.1.3 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a441bb8864121c2d1270a87f385ad98d6942e02705d640b02e39ecd4f4f429d
-  data.tar.gz: bffc65fe34303b5396b2d08df716022897dcdb98c36a627d7a63fe389210568f
+  metadata.gz: 83c3f6a3607f3e28d1b95b790b1eec081673e596db8ed02a868bc31eb54fe884
+  data.tar.gz: a2f57f3c3604fb05953949114cf2e3a315c0ab61af40c0d50ee59a2a0c23a87a
 SHA512:
-  metadata.gz: 8fb41c8fef25b7c9d16a7cbae97c974abab53c754baedc1336e74064139f4c7e286c9ef5c1bf0fef386482f82199327f6576345dbe416cf10c4b200ec698ecd8
-  data.tar.gz: de587e5a60a63385ff740cccc6bef444e3bf18abb9fb3580af2f5a16f70cd58bd64897e2b0e79851c6c1ed68658b219c25c7b54eb129b8c40ad3a87d7bd348ea
+  metadata.gz: 108fd4431a1fd08f619ff084b8304dddd25bfc1cadf218265bdc12f7dc3e7609a551daa2b6e1a9c433dcdca5a51bccf5c916be12700bdd880b03aca422d03ca0
+  data.tar.gz: 1243f5f9894c7c7750bbd991a4e9dc7b6b8c5d80f4fd68e77798cccb97b41dc7efd7039e4e3176178f9fda0804c67643f2770098d34ff8c4105f8005320a6799

data/CHANGELOG.md

@@ -1,5 +1,126 @@
 # AppSignal for Ruby gem Changelog
 
+## 4.2.0
+
+_Published on 2024-11-13._
+
+### Added
+
+- Add `config/appsignal.rb` config file support. When a `config/appsignal.rb` file is present in the app, the Ruby gem will automatically load it when `Appsignal.start` is called.
+
+  The `config/appsignal.rb` config file is a replacement for the `config/appsignal.yml` config file. When both files are present, only the `config/appsignal.rb` config file is loaded when the configuration file is automatically loaded by AppSignal  when the configuration file is automatically loaded by AppSignal.
+
+  Example `config/appsignal.rb` config file:
+
+  ```ruby
+  # config/appsignal.rb
+  Appsignal.configure do |config|
+    config.name = "My app name"
+  end
+  ```
+
+  To configure different option values for environments in the `config/appsignal.rb` config file, use if-statements:
+
+  ```ruby
+  # config/appsignal.rb
+  Appsignal.configure do |config|
+    config.name = "My app name"
+    if config.env == "production"
+      config.ignore_actions << "My production action"
+    end
+    if config.env == "staging"
+      config.ignore_actions << "My staging action"
+    end
+  end
+  ```
+
+  (minor [f81248bc](https://github.com/appsignal/appsignal-ruby/commit/f81248bc9c557197a0dd123c6d5958f21c11af9d), [48d16c7a](https://github.com/appsignal/appsignal-ruby/commit/48d16c7ab4dbc35ac3d56ecf042ca165d609bb64))
+- Add the `config/appsignal.rb` Ruby config file method to installer, `appsignal install`. (patch [0d2e2bde](https://github.com/appsignal/appsignal-ruby/commit/0d2e2bde5da510f0d339673cdcdb9f79030acf59))
+- Add `Appsignal.set_empty_params!` helper method. This helper method can be used to unset parameters on a transaction and to prevent the Appsignal instrumentation from adding parameters to a transaction.
+
+  Example usage:
+
+  ```ruby
+  class PaymentsController < ApplicationController
+    def create
+      Appsignal.set_empty_params!
+
+      # Do things with sensitive parameters
+    end
+  end
+  ```
+
+  When `Appsignal.add_params` is called afterward, the "empty parameters" state is cleared and any AppSignal instrumentation (if called afterward) will also add parameters again.
+
+  ```ruby
+  # Example: Unset parameters when set
+  Appsignal.add_params("abc" => "def")
+  # Parameters: { "abc" => "def" }
+  Appsignal.set_empty_params!
+  # Parameters: {}
+
+  # Example: When AppSignal instrumentation sets parameters:
+  Appsignal.set_empty_params!
+  # Parameters: {}
+  # Pseudo example code:
+  Appsignal::Instrumentation::SomeLibrary.new.add_params("xyz" => "...")
+  # Parameters: {}
+
+  # Example: Set parameters after them being unset previously
+  Appsignal.set_empty_params!
+  # Parameters: {}
+  Appsignal.add_params("abc" => "def")
+  # Parameters: { "abc" => "def" }
+  ```
+
+  (patch [20a8050e](https://github.com/appsignal/appsignal-ruby/commit/20a8050e63605f08e9377dda84b3a422810dd49a), [23627cd7](https://github.com/appsignal/appsignal-ruby/commit/23627cd7e7c2b2939c43701228e77aa14eae5c68))
+- Add `Appsignal.configure` context `env?` helper method. Check if the loaded environment matches the given environment using the `.env?(:env_name)` helper.
+
+  Example:
+
+  ```ruby
+  Appsignal.configure do |config|
+    # Symbols work as the argument
+    if config.env?(:production)
+      config.ignore_actions << "My production action"
+    end
+
+    # Strings also work as the argument
+    if config.env?("staging")
+      config.ignore_actions << "My staging action"
+    end
+  end
+  ```
+
+  (patch [8b234cae](https://github.com/appsignal/appsignal-ruby/commit/8b234caee4c29f9550c4dc77d02ebd21f8dbfa30))
+- Allow for default attributes to be given when initialising a `Logger` instance:
+
+  ```ruby
+  order_logger = Appsignal::Logger.new("app", attributes: { order_id: 123 })
+  ```
+
+  All log lines reported by this logger will contain the given attribute. Attributes given when reporting the log line will be merged with the default attributes for the logger, with those in the log line taking priority.
+
+  (patch [27e05af6](https://github.com/appsignal/appsignal-ruby/commit/27e05af6cb1e1ebca1fd6e8038da290f42db2bdb), [8be7c791](https://github.com/appsignal/appsignal-ruby/commit/8be7c7912eea4d3df74f1ca8808b7d6e8802f550))
+
+### Changed
+
+- Read the Hanami Action name without metaprogramming in Hanami 2.2 and newer. This makes our instrumentation more stable whenever something changes in future Hanami releases. (patch [c6848504](https://github.com/appsignal/appsignal-ruby/commit/c68485043feee13a49400f57c9a77d48f670f0f2))
+- Ignore these Hanami errors by default:
+
+  - Hanami::Router::NotAllowedError (for example: sending a GET request to POST endpoint)
+  - Hanami::Router::NotFoundError
+
+  They are usually errors you don't want to be notified about, so we ignore them by default now.
+
+  Customize the `ignore_errors` config option to continue receiving these errors.
+
+  (patch [f1500987](https://github.com/appsignal/appsignal-ruby/commit/f1500987b7b73ab2873202ea7301f2cfb19acdc7))
+
+### Fixed
+
+- Fix request parameter reporting for Hanami 2.2. (patch [ca22ed54](https://github.com/appsignal/appsignal-ruby/commit/ca22ed54de513773c5ee387f28ad98ee8f301627))
+
 ## 4.1.3
 
 _Published on 2024-11-07._

data/build_matrix.yml

@@ -85,6 +85,7 @@ matrix:
       - "rails-7.0"
       - "rails-7.1"
       - "rails-7.2"
+      - "rails-8.0"
 
   ruby:
     - ruby: "3.3.4"
@@ -120,6 +121,12 @@ matrix:
           - "3.2.5"
           - "3.1.6"
           - "3.0.7"
+    - gem: "hanami-2.2"
+      only:
+        ruby:
+          - "3.3.4"
+          - "3.2.5"
+          - "3.1.6"
     - gem: "http5"
     - gem: "padrino"
     - gem: "psych-3"
@@ -179,6 +186,11 @@ matrix:
           - "3.2.5"
           - "3.1.6"
           - "jruby-9.4.7.0"
+    - gem: "rails-8.0"
+      only:
+        ruby:
+          - "3.3.4"
+          - "3.2.5"
     - gem: "sequel"
     - gem: "sinatra"
     - gem: "webmachine2"

data/lib/appsignal/cli/diagnose.rb

@@ -188,15 +188,16 @@ module Appsignal
         end
 
         def configure_appsignal(options)
+          env_option = options.fetch(:environment, nil)
           # Try and load the Rails app, if any.
           # This will configure AppSignal through the config file or an
           # initializer.
-          require_rails_app_if_present
+          require_rails_app_if_present(env_option)
 
-          # If no config was found by loading the app, load with the defaults.
-          Appsignal.configure(options.fetch(:environment, nil))
-          Appsignal.config.write_to_environment
+          # No config loaded yet, try loading as normal
+          Appsignal._load_config!(env_option) unless Appsignal.config
           Appsignal._start_logger
+          Appsignal.config.write_to_environment
           Appsignal.internal_logger.info("Starting AppSignal diagnose")
         end
 
@@ -631,9 +632,12 @@ module Appsignal
           puts "\n"
         end
 
-        def require_rails_app_if_present
+        def require_rails_app_if_present(env_option)
           return unless rails_present?
 
+          # Set the environment given as an option to the diagnose CLI so the
+          # Rails app uses it when loaded.
+          ENV["_APPSIGNAL_CONFIG_FILE_ENV"] = env_option
           # Mark app as Rails app
           data[:app][:rails] = true
           # Manually require the railtie, because it wasn't loaded when the CLI
@@ -649,6 +653,8 @@ module Appsignal
           puts error.backtrace
           data[:app][:load_error] =
             "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+        ensure
+          ENV.delete("_APPSIGNAL_CONFIG_FILE_ENV")
         end
 
         def rails_present?

data/lib/appsignal/cli/install.rb

@@ -229,35 +229,49 @@ module Appsignal
           done_notice
         end
 
-        def configure(config, environments, name_overwritten)
+        def configure(config, environments, name_overwritten) # rubocop:disable Metrics/AbcSize
           install_for_capistrano
 
           ENV["APPSIGNAL_APP_ENV"] = "development"
 
           puts "How do you want to configure AppSignal?"
-          puts "  (1) a config file"
-          puts "  (2) environment variables"
+          puts "  (1) a Ruby config file"
+          puts "  (2) a YAML config file (legacy)"
+          puts "  (3) 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): "
+          loop do # rubocop:disable Metrics/BlockLength
+            print "  Choose (1-3): "
             case ask_for_input
             when "1"
               puts
-              print "Writing config file"
+              print "Writing Ruby config file"
               periods
               puts
-              puts colorize "  Config file written to config/appsignal.yml", :green
-              write_config_file(
+              write_ruby_config_file(
                 :push_api_key => config[:push_api_key],
                 :app_name => config[:name],
                 :environments => environments
               )
+              puts colorize "  Config file written to config/appsignal.rb", :green
               puts
               break
             when "2"
+              puts
+              print "Writing YAML config file"
+              periods
+              puts
+              write_yaml_config_file(
+                :push_api_key => config[:push_api_key],
+                :app_name => config[:name],
+                :environments => environments
+              )
+              puts colorize "  Config file written to config/appsignal.yml", :green
+              puts
+              break
+            when "3"
               ENV["APPSIGNAL_ACTIVE"] = "true"
               ENV["APPSIGNAL_PUSH_API_KEY"] = config[:push_api_key]
               ENV["APPSIGNAL_APP_NAME"] = config[:name]
@@ -325,17 +339,37 @@ module Appsignal
           ).map { |o| File.basename(o, ".rb") }.sort - EXCLUDED_ENVIRONMENTS
         end
 
-        def write_config_file(data)
-          filename = File.join(
+        def write_ruby_config_file(data)
+          template = File.join(
+            File.dirname(__FILE__),
+            "../../../resources/appsignal.rb.erb"
+          )
+          write_config_file(
+            template,
+            File.join(Dir.pwd, "config/appsignal.rb"),
+            data
+          )
+        end
+
+        def write_yaml_config_file(data)
+          template = File.join(
             File.dirname(__FILE__),
             "../../../resources/appsignal.yml.erb"
           )
-          file_contents = File.read(filename)
+          write_config_file(
+            template,
+            File.join(Dir.pwd, "config/appsignal.yml"),
+            data
+          )
+        end
+
+        def write_config_file(template_path, path, data)
+          file_contents = File.read(template_path)
           template = ERB.new(file_contents, :trim_mode => "-")
           config = template.result(OpenStruct.new(data).instance_eval { binding })
 
           FileUtils.mkdir_p(File.join(Dir.pwd, "config"))
-          File.write(File.join(Dir.pwd, "config/appsignal.yml"), config)
+          File.write(path, config)
         end
 
         def new_config

data/lib/appsignal/config.rb

@@ -35,6 +35,7 @@ module Appsignal
     def self.determine_env(initial_env = nil)
       [
         initial_env,
+        ENV.fetch("_APPSIGNAL_CONFIG_FILE_ENV", nil), # PRIVATE ENV var used by the diagnose CLI
         ENV.fetch("APPSIGNAL_APP_ENV", nil),
         ENV.fetch("RAILS_ENV", nil),
         ENV.fetch("RACK_ENV", nil)
@@ -53,6 +54,9 @@ module Appsignal
     # Determine which root path AppSignal should initialize with.
     # @api private
     def self.determine_root_path
+      app_path_env_var = ENV.fetch("APPSIGNAL_APP_PATH", nil)
+      return app_path_env_var if app_path_env_var
+
       loader_defaults.reverse.each do |loader_defaults|
         root_path = loader_defaults[:root_path]
         return root_path if root_path
@@ -61,6 +65,26 @@ module Appsignal
       Dir.pwd
     end
 
+    # @api private
+    class Context
+      DSL_FILENAME = "config/appsignal.rb"
+
+      attr_reader :env, :root_path
+
+      def initialize(env: nil, root_path: nil)
+        @env = env
+        @root_path = root_path
+      end
+
+      def dsl_config_file
+        File.join(root_path, DSL_FILENAME)
+      end
+
+      def dsl_config_file?
+        File.exist?(dsl_config_file)
+      end
+    end
+
     # @api private
     DEFAULT_CONFIG = {
       :activejob_report_errors => "all",
@@ -213,8 +237,10 @@ module Appsignal
     #   How to integrate AppSignal manually
     def initialize(
       root_path,
-      env
+      env,
+      load_yaml_file: true
     )
+      @load_yaml_file = load_yaml_file
       @root_path = root_path.to_s
       @config_file_error = false
       @config_file = config_file
@@ -269,8 +295,20 @@ module Appsignal
       @initial_config[:env] = @env
 
       # Load the config file if it exists
-      @file_config = load_from_disk || {}
-      merge(file_config)
+      if @load_yaml_file
+        @file_config = load_from_disk || {}
+        merge(file_config)
+      elsif yml_config_file?
+        # When in a `config/appsignal.rb` file and it detects a
+        # `config/appsignal.yml` file.
+        # Only logged and printed on `Appsignal.start`.
+        message = "Both a Ruby and YAML configuration file are found. " \
+          "The `config/appsignal.yml` file is ignored when the " \
+          "config is loaded from `config/appsignal.rb`. Move all config to " \
+          "the `config/appsignal.rb` file and remove the " \
+          "`config/appsignal.yml` file."
+        Appsignal::Utils::StdoutAndLoggerMessage.warning(message)
+      end
 
       # Load config from environment variables
       @env_config = load_from_environment
@@ -435,6 +473,13 @@ module Appsignal
       config_hash.transform_values(&:freeze)
     end
 
+    # @api private
+    def yml_config_file?
+      return false unless config_file
+
+      File.exist?(config_file)
+    end
+
     private
 
     def logger
@@ -458,7 +503,7 @@ module Appsignal
     end
 
     def load_from_disk
-      return if !config_file || !File.exist?(config_file)
+      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)
@@ -564,6 +609,15 @@ module Appsignal
         @config.env
       end
 
+      # Returns true if the given environment name matches the loaded
+      # environment name.
+      #
+      # @param given_env [String, Symbol]
+      # @return [TrueClass, FalseClass]
+      def env?(given_env)
+        env == given_env.to_s
+      end
+
       def activate_if_environment(*envs)
         self.active = envs.map(&:to_s).include?(env)
       end

data/lib/appsignal/extension/jruby.rb

@@ -80,7 +80,7 @@ module Appsignal
 
         # Logging methods
         attach_function :appsignal_log,
-          [:appsignal_string, :int32, :appsignal_string, :pointer],
+          [:appsignal_string, :int32, :int32, :appsignal_string, :pointer],
           :void
 
         # Transaction methods
@@ -273,10 +273,11 @@ module Appsignal
         make_ruby_string state if state[:len] > 0
       end
 
-      def log(group, level, message, attributes)
+      def log(group, level, format, message, attributes)
         appsignal_log(
           make_appsignal_string(group),
           level,
+          format,
           make_appsignal_string(message),
           attributes.pointer
         )

data/lib/appsignal/helpers/instrumentation.rb

@@ -556,11 +556,20 @@ module Appsignal
 
       # Mark the parameters sample data to be set as an empty value.
       #
-      # @api private
-      # @since 4.0.0
+      # Use this helper to unset request parameters / background job arguments
+      # and not report any for this transaction.
+      #
+      # If parameters would normally be added by AppSignal instrumentations of
+      # libraries, these parameters will not be added to the Transaction.
+      #
+      # Calling {#add_params} after this helper will add new parameters to the
+      # transaction.
+      #
+      # @since 4.2.0
       # @return [void]
       #
-      # @see Helpers::Instrumentation#set_empty_params!
+      # @see Transaction#set_empty_params!
+      # @see Transaction#set_params_if_nil
       def set_empty_params!
         return unless active?
         return unless Appsignal::Transaction.current?

data/lib/appsignal/loaders/hanami.rb

@@ -9,7 +9,11 @@ module Appsignal
         hanami_app_config = ::Hanami.app.config
         register_config_defaults(
           :root_path => hanami_app_config.root.to_s,
-          :env => hanami_app_config.env
+          :env => hanami_app_config.env,
+          :ignore_errors => [
+            "Hanami::Router::NotAllowedError",
+            "Hanami::Router::NotFoundError"
+          ]
         )
       end
 
@@ -23,9 +27,12 @@ module Appsignal
         )
         hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
 
+        return unless Gem::Version.new(Hanami::VERSION) < Gem::Version.new("2.2.0")
+
         ::Hanami::Action.prepend Appsignal::Loaders::HanamiLoader::HanamiIntegration
       end
 
+      # Legacy instrumentation to set the action name in Hanami apps older than Hanami 2.2
       module HanamiIntegration
         def call(env)
           super

data/lib/appsignal/logger.rb

@@ -25,15 +25,18 @@ module Appsignal
     # Create a new logger instance
     #
     # @param group Name of the group for this logger.
-    # @param level Log level to filter with
+    # @param level Minimum log level to report. Log lines below this level will be ignored.
+    # @param format Format to use to parse log line attributes.
+    # @param attributes Default attributes for all log lines.
     # @return [void]
-    def initialize(group, level: INFO, format: PLAINTEXT)
+    def initialize(group, level: INFO, format: PLAINTEXT, attributes: {})
       raise TypeError, "group must be a string" unless group.is_a? String
 
       @group = group
       @level = level
       @format = format
       @mutex = Mutex.new
+      @default_attributes = attributes
     end
 
     # We support the various methods in the Ruby
@@ -156,8 +159,10 @@ module Appsignal
 
     private
 
+    attr_reader :default_attributes
+
     def add_with_attributes(severity, message, group, attributes)
-      Thread.current[:appsignal_logger_attributes] = attributes
+      Thread.current[:appsignal_logger_attributes] = default_attributes.merge(attributes)
       add(severity, message, group)
     ensure
       Thread.current[:appsignal_logger_attributes] = nil

data/lib/appsignal/rack/hanami_middleware.rb

@@ -12,12 +12,25 @@ module Appsignal
 
       private
 
+      HANAMI_ACTION_INSTANCE = "hanami.action_instance"
+      ROUTER_PARAMS = "router.params"
+
       def add_transaction_metadata_after(transaction, request)
+        action_name = fetch_hanami_action(request.env)
+        transaction.set_action_if_nil(action_name) if action_name
         transaction.add_params { params_for(request) }
       end
 
       def params_for(request)
-        ::Hanami::Action.params_class.new(request.env).to_h
+        request.env.fetch(ROUTER_PARAMS, nil)
+      end
+
+      def fetch_hanami_action(env)
+        # This env key is available in Hanami 2.2+
+        action_instance = env.fetch(HANAMI_ACTION_INSTANCE, nil)
+        return unless action_instance
+
+        action_instance.class.name
       end
     end
   end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "4.1.3"
+  VERSION = "4.2.0"
 end

data/lib/appsignal.rb

@@ -103,6 +103,13 @@ module Appsignal
         return
       end
 
+      if config_file_context?
+        internal_logger.warn(
+          "Ignoring call to Appsignal.start in config file context."
+        )
+        return
+      end
+
       unless extension_loaded?
         internal_logger.info("Not starting AppSignal, extension is not loaded")
         return
@@ -110,9 +117,7 @@ module Appsignal
 
       internal_logger.debug("Loading AppSignal gem")
 
-      @config ||= Config.new(Config.determine_root_path, Config.determine_env)
-      @config.validate
-
+      _load_config!
       _start_logger
 
       if config.valid?
@@ -142,6 +147,41 @@ module Appsignal
       end
     end
 
+    # PRIVATE METHOD. DO NOT USE.
+    #
+    # @param env_var [String, NilClass] Used by diagnose CLI to pass through
+    #   the environment CLI option value.
+    # @api private
+    def _load_config!(env_param = nil)
+      context = Appsignal::Config::Context.new(
+        :env => Config.determine_env(env_param),
+        :root_path => Config.determine_root_path
+      )
+      # If there's a config/appsignal.rb file
+      if context.dsl_config_file?
+        if config
+          # When calling `Appsignal.configure` from an app, not the
+          # `config/appsignal.rb` file, with also a Ruby config file present.
+          message = "The `Appsignal.configure` helper is called from within an " \
+            "app while a `#{context.dsl_config_file}` file is present. " \
+            "The `config/appsignal.rb` file is ignored when the " \
+            "config is loaded with `Appsignal.configure` from within an app. " \
+            "We recommend moving all config to the `config/appsignal.rb` file " \
+            "or the `Appsignal.configure` helper in the app."
+          Appsignal::Utils::StdoutAndLoggerMessage.warning(message)
+        else
+          # Load it when no config is present
+          load_dsl_config_file(context.dsl_config_file, env_param)
+        end
+      else
+        # Load config if no config file was found and no config is present yet
+        # This will load the config/appsignal.yml file automatically
+        @config ||= Config.new(context.root_path, context.env)
+      end
+      # Validate the config, if present
+      config&.validate
+    end
+
     # Stop AppSignal's agent.
     #
     # Stops the AppSignal agent. Call this before the end of your program to
@@ -222,7 +262,7 @@ module Appsignal
     #   # Or for the environment given as an argument
     #   Appsignal.configure(:production)
     #
-    # @param env [String, Symbol] The environment to load.
+    # @param env_param [String, Symbol] The environment to load.
     # @param root_path [String] The path to look the `config/appsignal.yml` config file in.
     #   Defaults to the current working directory.
     # @yield [Config] Gives the {Config} instance to the block.
@@ -244,10 +284,28 @@ module Appsignal
       else
         @config = Config.new(
           root_path_param || Config.determine_root_path,
-          Config.determine_env(env_param)
+          Config.determine_env(env_param),
+          # If in the context of an `config/appsignal.rb` config file, do not
+          # load the `config/appsignal.yml` file.
+          # The `.rb` file is a replacement for the `.yml` file so it shouldn't
+          # load both.
+          :load_yaml_file => !config_file_context?
         )
       end
 
+      # When calling `Appsignal.configure` from a Rails initializer and a YAML
+      # file is present. We will not load the YAML file in the future.
+      if !config_file_context? && config.yml_config_file?
+        message = "The `Appsignal.configure` helper is called while a " \
+          "`config/appsignal.yml` file is present. In future versions the " \
+          "`config/appsignal.yml` file will be ignored when loading the " \
+          "config. We recommend moving all config to the " \
+          "`config/appsignal.rb` file, or the `Appsignal.configure` helper " \
+          "in Rails initializer file, and remove the " \
+          "`config/appsignal.yml` file."
+        Appsignal::Utils::StdoutAndLoggerMessage.warning(message)
+      end
+
       config_dsl = Appsignal::Config::ConfigDSL.new(config)
       return unless block_given?
 
@@ -397,6 +455,11 @@ module Appsignal
       config&.active? && extension_loaded?
     end
 
+    # @api private
+    def dsl_config_file_loaded?
+      defined?(@dsl_config_file_loaded) ? true : false
+    end
+
     private
 
     def params_match_loaded_config?(env_param, root_path_param)
@@ -408,6 +471,52 @@ module Appsignal
         (root_path_param.nil? || config.root_path == root_path_param)
     end
 
+    # Load the `config/appsignal.rb` config file, if present.
+    #
+    # If the config file has already been loaded once and it's trying to be
+    # loaded more than once, which should never happen, it will not do
+    # anything.
+    def load_dsl_config_file(path, env_param = nil)
+      return if defined?(@dsl_config_file_loaded)
+
+      begin
+        ENV["_APPSIGNAL_CONFIG_FILE_CONTEXT"] = "true"
+        ENV["_APPSIGNAL_CONFIG_FILE_ENV"] = env_param if env_param
+        @dsl_config_file_loaded = true
+        require path
+      rescue => error
+        @config_file_error = error
+        message = "Not starting AppSignal because an error occurred while " \
+          "loading the AppSignal config file.\n" \
+          "File: #{path.inspect}\n" \
+          "#{error.class.name}: #{error}"
+        Kernel.warn "appsignal ERROR: #{message}"
+        internal_logger.error "#{message}\n#{error.backtrace.join("\n")}"
+      ensure
+        unless Appsignal.config
+          # Ensure _a config object_ is present, even if something went wrong
+          # loading it or the file is empty. In this config file context, see
+          # the context env vars, it will intentionally not load the YAML file.
+          Appsignal.configure
+
+          # Disable if no config was loaded from the file but it is present
+          config[:active] = false
+        end
+
+        # Disable on config file error
+        config[:active] = false if defined?(@config_file_error)
+
+        ENV.delete("_APPSIGNAL_CONFIG_FILE_CONTEXT")
+        ENV.delete("_APPSIGNAL_CONFIG_FILE_ENV")
+      end
+    end
+
+    # Returns true if we're currently in the `config/appsignal.rb` file
+    # context.
+    def config_file_context?
+      ENV.fetch("_APPSIGNAL_CONFIG_FILE_CONTEXT", nil) == "true"
+    end
+
     def start_internal_stdout_logger
       @internal_logger = Appsignal::Utils::IntegrationLogger.new($stdout)
       internal_logger.formatter = log_formatter("appsignal")

data/resources/appsignal.rb.erb

@@ -0,0 +1,22 @@
+# AppSignal Ruby gem configuration
+# Visit our documentation for a list of all available configuration options.
+# https://docs.appsignal.com/ruby/configuration/options.html
+Appsignal.configure do |config|
+  config.activate_if_environment(<%= environments.map(&:inspect).join(", ") %>)
+  config.name = <%= app_name.inspect %>
+  # The application's Push API key
+  # We recommend removing this line and setting this option with the
+  # APPSIGNAL_PUSH_API_KEY environment variable instead.
+  # https://docs.appsignal.com/ruby/configuration/options.html#option-push_api_key
+  config.push_api_key = "<%= push_api_key %>"
+
+  # Configure actions that should not be monitored by AppSignal.
+  # For more information see our docs:
+  # https://docs.appsignal.com/ruby/configuration/ignore-actions.html
+  # config.ignore_actions << "ApplicationController#isup"
+
+  # Configure errors that should not be recorded by AppSignal.
+  # For more information see our docs:
+  # https://docs.appsignal.com/ruby/configuration/ignore-errors.html
+  # config.ignore_errors << "MyCustomError"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 4.1.3
+  version: 4.2.0
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2024-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -284,6 +284,7 @@ files:
 - lib/appsignal/version.rb
 - lib/puma/plugin/appsignal.rb
 - lib/sequel/extensions/appsignal_integration.rb
+- resources/appsignal.rb.erb
 - resources/appsignal.yml.erb
 - resources/cacert.pem
 homepage: https://github.com/appsignal/appsignal-ruby