appsignal 3.13.1 → 4.0.0.beta.1

data/spec/lib/appsignal/config_spec.rb

@@ -1,4 +1,81 @@
 describe Appsignal::Config do
+  describe ".add_loader_defaults" do
+    it "adds loader defaults to the list" do
+      described_class.add_loader_defaults(:loader1)
+
+      expect(described_class.loader_defaults).to include(
+        :name => :loader1,
+        :root_path => nil,
+        :env => nil,
+        :options => {}
+      )
+    end
+
+    it "registers multiple loaders in order of registration" do
+      described_class.add_loader_defaults(:loader1)
+      described_class.add_loader_defaults(:loader2)
+
+      expect(described_class.loader_defaults).to eq([
+        {
+          :name => :loader1,
+          :root_path => nil,
+          :env => nil,
+          :options => {}
+        },
+        {
+          :name => :loader2,
+          :root_path => nil,
+          :env => nil,
+          :options => {}
+        }
+      ])
+    end
+
+    it "adds loader with env and root_path" do
+      described_class.add_loader_defaults(
+        :loader1,
+        :root_path => "/some-path",
+        :env => "loader_env1"
+      )
+
+      expect(described_class.loader_defaults).to include(
+        :name => :loader1,
+        :root_path => "/some-path",
+        :env => "loader_env1",
+        :options => {}
+      )
+    end
+
+    it "adds loader with options" do
+      described_class.add_loader_defaults(
+        :loader1,
+        :my_option1 => "some value1",
+        :my_option2 => "some value2"
+      )
+
+      expect(described_class.loader_defaults).to include(
+        :name => :loader1,
+        :root_path => nil,
+        :env => nil,
+        :options => {
+          :my_option1 => "some value1",
+          :my_option2 => "some value2"
+        }
+      )
+    end
+
+    it "does not set any nil options" do
+      described_class.add_loader_defaults(:loader1, :nil_option => nil)
+
+      expect(described_class.loader_defaults).to include(
+        :name => :loader1,
+        :root_path => nil,
+        :env => nil,
+        :options => {}
+      )
+    end
+  end
+
   describe ".determine_env" do
     context "with env argument" do
       before { clear_integration_env_vars! }
@@ -126,15 +203,8 @@ describe Appsignal::Config do
           let(:env_env) { "my_env_env" }
           before { ENV["APPSIGNAL_APP_ENV"] = env_env }
 
-          it "uses the environment variable" do
-            expect(config.env).to eq(env_env)
-          end
-
           it "sets the environment as loaded through the env_config" do
-            expect(config.initial_config).to eq(:env => env)
             expect(config.env_config).to eq(:env => env_env)
-            expect(config.config_hash).to_not have_key(:env)
-            expect(config.config_hash).to_not have_key(:root_path)
           end
         end
       end
@@ -142,7 +212,7 @@ describe Appsignal::Config do
   end
 
   describe "config based on the system" do
-    let(:config) { silence { project_fixture_config(:none) } }
+    let(:config) { silence { build_config(:env => :none) } }
 
     describe ":active" do
       subject { config[:active] }
@@ -222,101 +292,59 @@ describe Appsignal::Config do
     end
   end
 
-  describe "initial config" do
-    let(:initial_config) do
-      {
-        :push_api_key => "abc",
-        :name => "TestApp",
-        :active => true,
-        :revision => "v2.5.1",
-        :request_headers => []
-      }
-    end
-    let(:config) do
-      described_class.new("non-existing-path", "production", initial_config)
+  describe "loader default config" do
+    let(:config) { described_class.new("some-path", "production") }
+    before do
+      define_loader(:options_loader) do
+        def on_load
+          register_config_defaults(
+            :env => "loader_env",
+            :root_path => "loader-path",
+            :ignore_actions => ["loader-action"],
+            :my_option => "my_value",
+            :nil_option => nil
+          )
+        end
+      end
+      load_loader(:options_loader)
     end
 
-    it "merges with the default config" do
-      expect(config.config_hash).to eq(
-        :active                         => true,
-        :activejob_report_errors        => "all",
-        :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
-        :debug                          => false,
-        :dns_servers                    => [],
-        :enable_allocation_tracking     => true,
-        :enable_gvl_global_timer        => true,
-        :enable_gvl_waiting_threads     => true,
-        :enable_host_metrics            => true,
-        :enable_minutely_probes         => true,
-        :enable_statsd                  => true,
-        :enable_nginx_metrics           => false,
-        :enable_rails_error_reporter    => true,
-        :enable_rake_performance_instrumentation => false,
-        :endpoint                       => "https://push.appsignal.com",
-        :files_world_accessible         => true,
-        :filter_metadata                => [],
-        :filter_parameters              => [],
-        :filter_session_data            => [],
-        :ignore_actions                 => [],
-        :ignore_errors                  => [],
-        :ignore_logs                    => [],
-        :ignore_namespaces              => [],
-        :instrument_http_rb             => true,
-        :instrument_net_http            => true,
-        :instrument_redis               => true,
-        :instrument_sequel              => true,
-        :log                            => "file",
-        :logging_endpoint               => "https://appsignal-endpoint.net",
-        :name                           => "TestApp",
-        :push_api_key                   => "abc",
-        :request_headers                => [],
-        :revision                       => "v2.5.1",
-        :send_environment_metadata      => true,
-        :send_params                    => true,
-        :send_session_data              => true,
-        :sidekiq_report_errors          => "all",
-        :transaction_debug_mode         => false
-      )
+    it "overrides the default config option values" do
+      expect(config[:ignore_actions]).to eq(["loader-action"])
     end
 
-    it "sets the initial_config" do
-      expect(config.initial_config).to eq(initial_config)
+    it "does not set any nil values" do
+      expect(config.config_hash).to_not have_key(:nil_option)
     end
 
-    describe "overriding system detected config" do
-      describe ":running_in_container" do
-        let(:config) do
-          described_class.new(
-            "non-existing-path",
-            "production",
-            :running_in_container => true
-          )
-        end
-        subject { config[:running_in_container] }
-
-        it "overrides system detected config" do
-          expect(subject).to be_truthy
-        end
-      end
+    it "does not set the env" do
+      # This is done by Config.determine_env
+      expect(config.env).to eq("production")
+    end
 
-      describe ":active" do
-        subject { config[:active] }
+    it "does not set the root_path" do
+      # This is done by Config.determine_root_path
+      expect(config.root_path).to eq("some-path")
+    end
 
-        context "with APPSIGNAL_PUSH_API_KEY env variable" do
-          let(:config) do
-            described_class.new(
-              "non-existing-path",
-              "production",
-              :active => false,
-              :request_headers => []
+    context "with multiple loaders" do
+      before do
+        define_loader(:options_loader2) do
+          def on_load
+            register_config_defaults(
+              :my_option => "second_value",
+              :second_option => "second_value"
             )
           end
-          before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
-
-          it "sets given config rather than env variable" do
-            expect(subject).to be_falsy
-          end
         end
+        load_loader(:options_loader2)
+      end
+
+      it "makes the first loader's config leading" do
+        expect(config.config_hash).to include(
+          :my_option => "my_value",
+          :second_option => "second_value"
+        )
       end
     end
   end
@@ -340,7 +368,7 @@ describe Appsignal::Config do
   end
 
   context "with a config file" do
-    let(:config) { project_fixture_config("production") }
+    let(:config) { build_config(:env => "production") }
 
     context "with valid config" do
       it "is valid and active" do
@@ -354,79 +382,32 @@ describe Appsignal::Config do
       end
     end
 
-    context "with an overridden config file" do
-      let(:config) do
-        project_fixture_config("production", {}, Appsignal.internal_logger,
-          File.join(project_fixture_path, "config", "appsignal.yml"))
-      end
-
-      it "is valid and active" do
-        expect(config.valid?).to be_truthy
-        expect(config.active?).to be_truthy
-      end
-
-      context "with an invalid overridden config file" do
-        let(:config) do
-          project_fixture_config("production", {}, Appsignal.internal_logger,
-            File.join(project_fixture_path, "config", "missing.yml"))
-        end
-
-        it "is not valid" do
-          expect(config.valid?).to be_falsy
-        end
-      end
-    end
-
     context "with the config file causing an error" do
       let(:config_path) do
         File.expand_path(
           File.join(File.dirname(__FILE__), "../../support/fixtures/projects/broken")
         )
       end
-      let(:config) { Appsignal::Config.new(config_path, "foo") }
-
-      context "when APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR is not set" do
-        it "logs & prints an error, skipping the file source" do
-          stdout = std_stream
-          stderr = std_stream
-          log = capture_logs { capture_std_streams(stdout, stderr) { config } }
-          message = "An error occurred while loading the AppSignal config file. " \
-            "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.\n" \
-            "File: #{File.join(config_path, "config", "appsignal.yml").inspect}\n" \
-            "KeyError: key not found"
-          expect(log).to contains_log :error, message
-          expect(log).to include("/appsignal/config.rb:") # Backtrace
-          expect(stdout.read).to_not include("appsignal:")
-          expect(stderr.read).to include "appsignal: #{message}"
-          expect(config.file_config).to eql({})
-        end
-      end
-
-      context "when APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR=1 is set" do
-        it "does not start AppSignal, logs & prints an error" do
-          stdout = std_stream
-          stderr = std_stream
-          ENV["APPSIGNAL_ACTIVE"] = "true"
-          ENV["APPSIGNAL_APP_NAME"] = "My app"
-          ENV["APPSIGNAL_APP_ENV"] = "dev"
-          ENV["APPSIGNAL_PUSH_API_KEY"] = "something valid"
-          ENV["APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR"] = "1"
-          log = capture_logs { capture_std_streams(stdout, stderr) { config } }
-          message = "An error occurred while loading the AppSignal config file. " \
-            "Not starting AppSignal because APPSIGNAL_INACTIVE_ON_CONFIG_FILE_ERROR is set.\n" \
-            "File: #{File.join(config_path, "config", "appsignal.yml").inspect}\n" \
-            "KeyError: key not found"
-          expect(log).to contains_log :error, message
-          expect(log).to include("/appsignal/config.rb:") # Backtrace
-          expect(stdout.read).to_not include("appsignal:")
-          expect(stderr.read).to include "appsignal: #{message}"
-          expect(config.file_config).to eql({})
-          expect(config.active?).to be(false)
-        end
+      let(:config) { described_class.new(config_path, "production") }
+
+      it "does not start AppSignal, logs & prints an error" do
+        stdout = std_stream
+        stderr = std_stream
+        ENV["APPSIGNAL_ACTIVE"] = "true"
+        ENV["APPSIGNAL_APP_NAME"] = "My app"
+        ENV["APPSIGNAL_APP_ENV"] = "dev"
+        ENV["APPSIGNAL_PUSH_API_KEY"] = "something valid"
+        log = capture_logs { capture_std_streams(stdout, stderr) { config } }
+        message = "An error occurred while loading the AppSignal config file. " \
+          "Not starting AppSignal.\n" \
+          "File: #{File.join(config_path, "config", "appsignal.yml").inspect}\n" \
+          "KeyError: key not found"
+        expect(log).to contains_log :error, message
+        expect(log).to include("/appsignal/config.rb:") # Backtrace
+        expect(stdout.read).to_not include("appsignal:")
+        expect(stderr.read).to include "appsignal: #{message}"
+        expect(config.file_config).to eql({})
+        expect(config.active?).to be(false)
       end
     end
 
@@ -436,19 +417,20 @@ describe Appsignal::Config do
         :active => true,
         :push_api_key => "abc",
         :name => "TestApp",
-        :request_headers => kind_of(Array),
         :enable_minutely_probes => false
       )
     end
 
     describe "overriding system and defaults config" do
       let(:config) do
-        described_class.new(
-          "non-existing-path",
-          "production",
-          :running_in_container => true,
-          :debug => true,
-          :log_level => "debug"
+        build_config(
+          :root_path => "non-existing-path",
+          :env => "production",
+          :options => {
+            :running_in_container => true,
+            :debug => true,
+            :log_level => "debug"
+          }
         )
       end
 
@@ -460,7 +442,7 @@ describe Appsignal::Config do
     end
 
     context "with the env name as a symbol" do
-      let(:config) { project_fixture_config(:production) }
+      let(:config) { build_config(:env => :production) }
 
       it "loads the config" do
         expect(config.valid?).to be_truthy
@@ -471,9 +453,7 @@ describe Appsignal::Config do
     end
 
     context "without the selected env" do
-      let(:config) { project_fixture_config("nonsense") }
-      let(:log_stream) { std_stream }
-      let(:log) { log_contents(log_stream) }
+      let(:config) { build_config(:env => :nonsense) }
 
       it "is not valid or active" do
         expect(config.valid?).to be_falsy
@@ -481,10 +461,10 @@ describe Appsignal::Config do
       end
 
       it "logs an error" do
-        use_logger_with(log_stream) { config }
-        expect(log)
+        logs = capture_logs { config }
+        expect(logs)
           .to contains_log(:error, "Not loading from config file: config for 'nonsense' not found")
-        expect(log)
+        expect(logs)
           .to contains_log(:error, "Push API key not set after loading config")
       end
     end
@@ -494,10 +474,8 @@ describe Appsignal::Config do
     let(:config) do
       described_class.new(
         "non-existing-path",
-        "production",
-        :running_in_container => true,
-        :debug => true
-      )
+        "production"
+      ).tap(&:validate)
     end
     let(:working_directory_path) { File.join(tmp_dir, "test_working_directory_path") }
     let(:env_config) do
@@ -507,9 +485,9 @@ describe Appsignal::Config do
         :bind_address => "0.0.0.0",
         :ca_file_path => "/some/path",
         :cpu_count => 1.5,
-        :debug => true,
         :dns_servers => ["8.8.8.8", "8.8.4.4"],
         :enable_allocation_tracking => false,
+        :enable_at_exit_reporter => false,
         :enable_gvl_global_timer => false,
         :enable_gvl_waiting_threads => false,
         :enable_host_metrics => false,
@@ -547,10 +525,7 @@ describe Appsignal::Config do
         :send_params => false,
         :send_session_data => false,
         :sidekiq_report_errors => "all",
-        :skip_session_data => false,
         :statsd_port => "7890",
-        :transaction_debug_mode => false,
-        :working_dir_path => "/some/path",
         :working_directory_path => working_directory_path
       }
     end
@@ -573,13 +548,12 @@ describe Appsignal::Config do
         "APPSIGNAL_SIDEKIQ_REPORT_ERRORS" => "all",
         "APPSIGNAL_STATSD_PORT" => "7890",
         "APPSIGNAL_WORKING_DIRECTORY_PATH" => working_directory_path,
-        "APPSIGNAL_WORKING_DIR_PATH" => "/some/path",
         "APP_REVISION" => "v2.5.1",
 
         # Booleans
         "APPSIGNAL_ACTIVE" => "true",
-        "APPSIGNAL_DEBUG" => "true",
         "APPSIGNAL_ENABLE_ALLOCATION_TRACKING" => "false",
+        "APPSIGNAL_ENABLE_AT_EXIT_REPORTER" => "false",
         "APPSIGNAL_ENABLE_GVL_GLOBAL_TIMER" => "false",
         "APPSIGNAL_ENABLE_GVL_WAITING_THREADS" => "false",
         "APPSIGNAL_ENABLE_HOST_METRICS" => "false",
@@ -597,8 +571,6 @@ describe Appsignal::Config do
         "APPSIGNAL_SEND_ENVIRONMENT_METADATA" => "false",
         "APPSIGNAL_SEND_PARAMS" => "false",
         "APPSIGNAL_SEND_SESSION_DATA" => "false",
-        "APPSIGNAL_SKIP_SESSION_DATA" => "false",
-        "APPSIGNAL_TRANSACTION_DEBUG_MODE" => "false",
 
         # Arrays
         "APPSIGNAL_DNS_SERVERS" => "8.8.8.8,8.8.4.4",
@@ -665,12 +637,12 @@ describe Appsignal::Config do
 
     context "with mixed case `true` env variables values" do
       before do
-        ENV["APPSIGNAL_DEBUG"] = "TRUE"
+        ENV["APPSIGNAL_ENABLE_RAKE_PERFORMANCE_INSTRUMENTATION"] = "TRUE"
         ENV["APPSIGNAL_INSTRUMENT_SEQUEL"] = "True"
       end
 
       it "accepts mixed case `true` values" do
-        expect(config[:debug]).to eq(true)
+        expect(config[:enable_rake_performance_instrumentation]).to eq(true)
         expect(config[:instrument_sequel]).to eq(true)
       end
     end
@@ -680,146 +652,125 @@ describe Appsignal::Config do
     end
   end
 
-  describe "with config based on overrides" do
-    let(:log_stream) { StringIO.new }
-    let(:logger) { test_logger(log_stream) }
-    let(:logs) { log_contents(log_stream) }
+  describe "DSL config" do
+    let(:dsl_config) do
+      {
+        :push_api_key => "abc",
+        :name => "TestApp",
+        :active => true,
+        :revision => "v2.5.1",
+        :request_headers => []
+      }
+    end
     let(:config) do
-      described_class.new(Dir.pwd, "production", config_options, logger)
+      build_config(
+        :root_path => "non-existing-path",
+        :env => "production",
+        :options => dsl_config
+      )
     end
 
-    describe "skip_session_data" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:deprecation_message) do
-        "The `skip_session_data` config option is deprecated. Please use " \
-          "`send_session_data` instead."
-      end
-      before do
-        capture_std_streams(std_stream, err_stream) { config }
-      end
-
-      context "when not set" do
-        let(:config_options) { {} }
-
-        it "sets the default send_session_data value" do
-          expect(config[:skip_session_data]).to be_nil
-          expect(config[:send_session_data]).to eq(true)
-          expect(config.override_config[:send_session_data]).to eq(true)
-        end
-
-        it "does not print a deprecation warning" do
-          expect(stderr).to_not include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to_not include(deprecation_message)
-        end
-      end
-
-      context "when set to true" do
-        let(:config_options) { { :skip_session_data => true } }
-
-        it "sets send_session_data if send_session_data is not set by the user" do
-          expect(config[:skip_session_data]).to eq(true)
-          expect(config[:send_session_data]).to eq(false)
-          expect(config.override_config[:send_session_data]).to eq(false)
-        end
-
-        it "prints a deprecation warning" do
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to include(deprecation_message)
-        end
-      end
-
-      context "when set to false" do
-        let(:config_options) { { :skip_session_data => false } }
-
-        it "sets send_session_data if send_session_data is not set by the user" do
-          expect(config[:skip_session_data]).to eq(false)
-          expect(config[:send_session_data]).to eq(true)
-          expect(config.override_config[:send_session_data]).to eq(true)
-        end
-
-        it "prints a deprecation warning" do
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to include(deprecation_message)
-        end
-      end
+    it "merges with the default config" do
+      expect(config.config_hash).to eq(
+        :active                         => true,
+        :activejob_report_errors        => "all",
+        :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
+        :dns_servers                    => [],
+        :enable_allocation_tracking     => true,
+        :enable_at_exit_reporter        => true,
+        :enable_gvl_global_timer        => true,
+        :enable_gvl_waiting_threads     => true,
+        :enable_host_metrics            => true,
+        :enable_minutely_probes         => true,
+        :enable_statsd                  => true,
+        :enable_nginx_metrics           => false,
+        :enable_rails_error_reporter    => true,
+        :enable_rake_performance_instrumentation => false,
+        :endpoint                       => "https://push.appsignal.com",
+        :files_world_accessible         => true,
+        :filter_metadata                => [],
+        :filter_parameters              => [],
+        :filter_session_data            => [],
+        :ignore_actions                 => [],
+        :ignore_errors                  => [],
+        :ignore_logs                    => [],
+        :ignore_namespaces              => [],
+        :instrument_http_rb             => true,
+        :instrument_net_http            => true,
+        :instrument_redis               => true,
+        :instrument_sequel              => true,
+        :log                            => "file",
+        :logging_endpoint               => "https://appsignal-endpoint.net",
+        :name                           => "TestApp",
+        :push_api_key                   => "abc",
+        :request_headers                => [],
+        :revision                       => "v2.5.1",
+        :send_environment_metadata      => true,
+        :send_params                    => true,
+        :send_session_data              => true,
+        :sidekiq_report_errors          => "all"
+      )
+    end
 
-      context "when skip_session_data and send_session_data are both set" do
-        let(:config_options) { { :skip_session_data => true, :send_session_data => true } }
+    it "sets the dsl_config" do
+      expect(config.dsl_config).to eq(dsl_config)
+    end
 
-        it "does not overwrite the send_session_data value" do
-          expect(config[:skip_session_data]).to eq(true)
-          expect(config[:send_session_data]).to eq(true)
-          expect(config.override_config[:send_session_data]).to be_nil
-        end
+    describe "overriding system detected config" do
+      describe ":running_in_container" do
+        let(:dsl_config) { { :running_in_container => true } }
+        subject { config[:running_in_container] }
 
-        it "prints a deprecation warning" do
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to include(deprecation_message)
+        it "overrides system detected config" do
+          expect(subject).to be_truthy
         end
       end
-    end
 
-    if DependencyHelper.rails_present?
-      require "active_job"
+      describe ":active" do
+        subject { config[:active] }
 
-      context "activejob_report_errors" do
-        let(:config_options) { { :activejob_report_errors => "discard" } }
+        context "with APPSIGNAL_PUSH_API_KEY env variable" do
+          let(:dsl_config) { { :active => false } }
+          before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
 
-        if DependencyHelper.rails_version >= Gem::Version.new("7.1.0")
-          context "when Active Job >= 7.1 and 'discard'" do
-            it "does not override the activejob_report_errors value" do
-              expect(config[:activejob_report_errors]).to eq("discard")
-              expect(config.override_config[:activejob_report_errors]).to be_nil
-            end
-          end
-        else
-          context "when Active Job < 7.1 and 'discard'" do
-            it "sets activejob_report_errors to 'all'" do
-              expect(config[:activejob_report_errors]).to eq("all")
-              expect(config.override_config[:activejob_report_errors]).to eq("all")
-            end
+          it "sets given config rather than env variable" do
+            expect(subject).to be_falsy
           end
         end
       end
     end
 
-    context "sidekiq_report_errors" do
-      let(:config_options) { { :sidekiq_report_errors => "discard" } }
-      before do
-        if Appsignal::Hooks::SidekiqHook.instance_variable_defined?(:@version_5_1_or_higher)
-          Appsignal::Hooks::SidekiqHook.remove_instance_variable(:@version_5_1_or_higher)
-        end
+    describe "overriding loader config" do
+      let(:config) do
+        build_config(
+          :root_path => "non-existing-path",
+          :env => "production",
+          :options => { :my_option => "initial value" }
+        )
       end
-
-      context "when Sidekiq >= 5.1 and 'discard'" do
-        before { stub_const("Sidekiq::VERSION", "5.1.0") }
-
-        it "does not override the sidekiq_report_errors value" do
-          expect(config[:sidekiq_report_errors]).to eq("discard")
-          expect(config.override_config[:sidekiq_report_errors]).to be_nil
+      before do
+        define_loader(:test_loader) do
+          def on_load
+            register_config_defaults(:my_option => "loader value")
+          end
         end
+        load_loader(:test_loader)
       end
 
-      context "when Sidekiq < 5.1 and 'discard'" do
-        before { stub_const("Sidekiq::VERSION", "5.0.0") }
-
-        it "sets sidekiq_report_errors to 'all'" do
-          expect(config[:sidekiq_report_errors]).to eq("all")
-          expect(config.override_config[:sidekiq_report_errors]).to eq("all")
-        end
+      it "overrides loader config" do
+        expect(config[:my_option]).to eq("initial value")
       end
     end
   end
 
   describe "config keys" do
+    let(:config) { build_config(:options => options) }
+
     describe ":endpoint" do
       subject { config[:endpoint] }
 
       context "with an pre-0.12-style endpoint" do
-        let(:config) do
-          project_fixture_config("production", :endpoint => "https://push.appsignal.com/1")
-        end
+        let(:options) { { :endpoint => "https://push.appsignal.com/1" } }
 
         it "strips off the path" do
           expect(subject).to eq "https://push.appsignal.com"
@@ -827,7 +778,7 @@ describe Appsignal::Config do
       end
 
       context "with a non-standard port" do
-        let(:config) { project_fixture_config("production", :endpoint => "http://localhost:4567") }
+        let(:options) { { :endpoint => "http://localhost:4567" } }
 
         it "keeps the port" do
           expect(subject).to eq "http://localhost:4567"
@@ -839,7 +790,7 @@ describe Appsignal::Config do
       subject { config[:logging_endpoint] }
 
       context "with a non-standard port" do
-        let(:config) { project_fixture_config("production", :logging_endpoint => "http://localhost:4567") }
+        let(:options) { { :logging_endpoint => "http://localhost:4567" } }
 
         it "keeps the port" do
           expect(subject).to eq "http://localhost:4567"
@@ -849,7 +800,9 @@ describe Appsignal::Config do
   end
 
   describe "#[]" do
-    let(:config) { project_fixture_config(:none, :push_api_key => "foo", :request_headers => []) }
+    let(:config) do
+      build_config(:env => :none, :options => { :push_api_key => "foo", :request_headers => [] })
+    end
 
     context "with existing key" do
       it "gets the value" do
@@ -865,7 +818,7 @@ describe Appsignal::Config do
   end
 
   describe "#[]=" do
-    let(:config) { project_fixture_config(:none) }
+    let(:config) { build_config(:env => :none) }
 
     context "with existing key" do
       it "changes the value" do
@@ -885,7 +838,7 @@ describe Appsignal::Config do
   end
 
   describe "#write_to_environment" do
-    let(:config) { project_fixture_config(:production) }
+    let(:config) { build_config }
     before do
       config[:bind_address] = "0.0.0.0"
       config[:cpu_count] = 1.5
@@ -914,7 +867,6 @@ describe Appsignal::Config do
       expect(ENV.fetch("_APPSIGNAL_AGENT_PATH", nil)).to end_with("/ext")
       expect(ENV.fetch("_APPSIGNAL_BIND_ADDRESS", nil)).to eq("0.0.0.0")
       expect(ENV.fetch("_APPSIGNAL_CPU_COUNT", nil)).to eq("1.5")
-      expect(ENV.fetch("_APPSIGNAL_DEBUG_LOGGING", nil)).to eq "false"
       expect(ENV.fetch("_APPSIGNAL_LOG", nil)).to eq "stdout"
       expect(ENV.fetch("_APPSIGNAL_LOG_FILE_PATH", nil)).to end_with("/tmp/appsignal.log")
       expect(ENV.fetch("_APPSIGNAL_LOGGING_ENDPOINT", nil)).to eq "http://localhost:123"
@@ -938,13 +890,11 @@ describe Appsignal::Config do
         .to eq File.join(resources_dir, "cacert.pem")
       expect(ENV.fetch("_APPSIGNAL_DNS_SERVERS", nil)).to eq "8.8.8.8,8.8.4.4"
       expect(ENV.fetch("_APPSIGNAL_FILES_WORLD_ACCESSIBLE", nil)).to eq "true"
-      expect(ENV.fetch("_APPSIGNAL_TRANSACTION_DEBUG_MODE", nil)).to eq "true"
       expect(ENV.fetch("_APPSIGNAL_SEND_ENVIRONMENT_METADATA", nil)).to eq "false"
       expect(ENV.fetch("_APPSIGNAL_STATSD_PORT", nil)).to eq ""
       expect(ENV.fetch("_APPSIGNAL_FILTER_PARAMETERS", nil)).to eq "password,confirm_password"
       expect(ENV.fetch("_APPSIGNAL_FILTER_SESSION_DATA", nil)).to eq "key1,key2"
       expect(ENV.fetch("_APP_REVISION", nil)).to eq "v2.5.1"
-      expect(ENV).to_not have_key("_APPSIGNAL_WORKING_DIR_PATH")
       expect(ENV).to_not have_key("_APPSIGNAL_WORKING_DIRECTORY_PATH")
     end
 
@@ -970,17 +920,6 @@ describe Appsignal::Config do
       end
     end
 
-    context "with :working_dir_path" do
-      before do
-        config[:working_dir_path] = "/tmp/appsignal2"
-        config.write_to_environment
-      end
-
-      it "sets the modified :working_dir_path" do
-        expect(ENV.fetch("_APPSIGNAL_WORKING_DIR_PATH", nil)).to eq "/tmp/appsignal2"
-      end
-    end
-
     context "with :working_directory_path" do
       before do
         config[:working_directory_path] = "/tmp/appsignal2"
@@ -1007,7 +946,7 @@ describe Appsignal::Config do
   describe "#log_file_path" do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
-    let(:config) { project_fixture_config("production", :log_path => log_path) }
+    let(:config) { build_config(:options => { :log_path => log_path }) }
 
     def log_file_path
       capture_stdout(out_stream) { config.log_file_path }
@@ -1190,59 +1129,62 @@ describe Appsignal::Config do
     end
   end
 
-  describe "#maintain_backwards_compatibility" do
-    let(:log_stream) { StringIO.new }
-    let(:logger) { test_logger(log_stream) }
-    let(:logs) { log_contents(log_stream) }
+  describe "#validate" do
+    subject { config.valid? }
     let(:config) do
-      described_class.new(Dir.pwd, "production", config_options, logger)
+      build_config(:root_path => Dir.pwd, :env => "production", :options => config_options)
     end
 
-    describe "working_dir_path" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:deprecation_message) do
-        "The `working_dir_path` option is deprecated, please use " \
-          "`working_directory_path` instead and specify the " \
-          "full path to the working directory"
-      end
-      before do
-        capture_std_streams(std_stream, err_stream) { config }
-      end
+    if DependencyHelper.rails_present?
+      require "active_job"
 
-      context "when not set" do
-        let(:config_options) { {} }
+      context "activejob_report_errors" do
+        let(:config_options) { { :activejob_report_errors => "discard" } }
 
-        it "sets the default working_dir_path value" do
-          expect(config[:working_dir_path]).to be_nil
+        if DependencyHelper.rails_version >= Gem::Version.new("7.1.0")
+          context "when Active Job >= 7.1 and 'discard'" do
+            it "does not override the activejob_report_errors value" do
+              expect(config[:activejob_report_errors]).to eq("discard")
+              expect(config.override_config[:activejob_report_errors]).to be_nil
+            end
+          end
+        else
+          context "when Active Job < 7.1 and 'discard'" do
+            it "sets activejob_report_errors to 'all'" do
+              expect(config[:activejob_report_errors]).to eq("all")
+              expect(config.override_config[:activejob_report_errors]).to eq("all")
+            end
+          end
         end
+      end
+    end
 
-        it "does not print a deprecation warning" do
-          expect(stderr).to_not include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to_not include(deprecation_message)
+    context "sidekiq_report_errors" do
+      let(:config_options) { { :sidekiq_report_errors => "discard" } }
+      before do
+        if Appsignal::Hooks::SidekiqHook.instance_variable_defined?(:@version_5_1_or_higher)
+          Appsignal::Hooks::SidekiqHook.remove_instance_variable(:@version_5_1_or_higher)
         end
       end
 
-      context "when set" do
-        let(:config_options) { { :working_dir_path => "/tmp/appsignal2" } }
+      context "when Sidekiq >= 5.1 and 'discard'" do
+        before { stub_const("Sidekiq::VERSION", "5.1.0") }
 
-        it "sets the default working_dir_path value" do
-          expect(config[:working_dir_path]).to eq("/tmp/appsignal2")
+        it "does not override the sidekiq_report_errors value" do
+          expect(config[:sidekiq_report_errors]).to eq("discard")
+          expect(config.override_config[:sidekiq_report_errors]).to be_nil
         end
+      end
 
-        it "does not print a deprecation warning" do
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to include(deprecation_message)
+      context "when Sidekiq < 5.1 and 'discard'" do
+        before { stub_const("Sidekiq::VERSION", "5.0.0") }
+
+        it "sets sidekiq_report_errors to 'all'" do
+          expect(config[:sidekiq_report_errors]).to eq("all")
+          expect(config.override_config[:sidekiq_report_errors]).to eq("all")
         end
       end
     end
-  end
-
-  describe "#validate" do
-    subject { config.valid? }
-    let(:config) do
-      described_class.new(Dir.pwd, "production", config_options)
-    end
 
     describe "push_api_key" do
       let(:config_options) { { :push_api_key => push_api_key, :request_headers => [] } }
@@ -1284,7 +1226,7 @@ describe Appsignal::Config do
 
   describe "#log_level" do
     let(:options) { {} }
-    let(:config) { described_class.new("", nil, options) }
+    let(:config) { build_config(:root_path => "", :env => nil, :options => options) }
     subject { config.log_level }
 
     context "without any config" do
@@ -1293,16 +1235,6 @@ describe Appsignal::Config do
       end
     end
 
-    context "with debug set to true" do
-      let(:options) { { :debug => true } }
-      it { is_expected.to eq(Logger::DEBUG) }
-    end
-
-    context "with transaction_debug_mode set to true" do
-      let(:options) { { :transaction_debug_mode => true } }
-      it { is_expected.to eq(Logger::DEBUG) }
-    end
-
     context "with log_level set to error" do
       let(:options) { { :log_level => "error" } }
       it { is_expected.to eq(Logger::ERROR) }
@@ -1350,20 +1282,12 @@ describe Appsignal::Config do
       it "prints a warning and doesn't use the log_level" do
         is_expected.to eql(Logger::INFO)
       end
-
-      context "with debug option set to true" do
-        let(:options) { { :log_level => "fatal", :debug => true } }
-
-        it "prints a warning and sets it to debug" do
-          is_expected.to eql(Logger::DEBUG)
-        end
-      end
     end
   end
 
   describe Appsignal::Config::ConfigDSL do
     let(:env) { :production }
-    let(:config) { project_fixture_config(env) }
+    let(:config) { build_config(:env => env) }
     let(:dsl) { described_class.new(config) }
 
     describe "default options" do
@@ -1453,9 +1377,10 @@ describe Appsignal::Config do
       end
 
       it "logs a deprecation warning" do
-        logs = capture_logs do
-          silence { dsl.app_path = "foo" }
-        end
+        logs =
+          capture_logs do
+            silence { dsl.app_path = "foo" }
+          end
 
         expect(logs).to contains_log(
           :warn,