appsignal 3.10.0-java → 3.12.0-java

data/spec/lib/appsignal_spec.rb

@@ -2,22 +2,226 @@ describe Appsignal do
   include EnvironmentMetadataHelper
   around { |example| keep_transactions { example.run } }
 
-  before do
-    # Make sure we have a clean state because we want to test
-    # initialization here.
-    Appsignal.config = nil
-  end
-
   let(:transaction) { http_request_transaction }
 
   describe ".config=" do
-    it "should set the config" do
+    it "sets the config" do
       config = project_fixture_config
       expect(Appsignal.internal_logger).to_not receive(:level=)
 
-      Appsignal.config = config
+      silence { Appsignal.config = config }
       expect(Appsignal.config).to eq config
     end
+
+    it "prints a deprecation warning" do
+      err_stream = std_stream
+      capture_std_streams(std_stream, err_stream) do
+        Appsignal.config = project_fixture_config
+      end
+      expect(err_stream.read).to include(
+        "appsignal WARNING: Configuring AppSignal with `Appsignal.config=` is deprecated."
+      )
+    end
+
+    it "logs a deprecation warning" do
+      logs = capture_logs { silence { Appsignal.config = project_fixture_config } }
+      expect(logs).to contains_log(
+        :warn,
+        "Configuring AppSignal with `Appsignal.config=` is deprecated."
+      )
+    end
+  end
+
+  describe ".configure" do
+    context "when active" do
+      it "doesn't update the config" do
+        start_agent
+        Appsignal::Testing.store[:config_called] = false
+        expect do
+          Appsignal.configure do |_config|
+            Appsignal::Testing.store[:config_called] = true
+          end
+        end.to_not(change { [Appsignal.config, Appsignal.active?] })
+        expect(Appsignal::Testing.store[:config_called]).to be(false)
+      end
+
+      it "logs a warning" do
+        start_agent
+        logs =
+          capture_logs do
+            Appsignal.configure do |_config|
+              # Do something
+            end
+          end
+        expect(logs).to contains_log(
+          :warn,
+          "AppSignal is already started. Ignoring `Appsignal.configure` call."
+        )
+      end
+    end
+
+    context "with config but not started" do
+      it "reuses the already loaded config if the env is the same" do
+        Appsignal._config = Appsignal::Config.new(
+          project_fixture_path,
+          :my_env,
+          :ignore_actions => ["My action"]
+        )
+
+        Appsignal.configure(:my_env) do |config|
+          expect(config.ignore_actions).to eq(["My action"])
+          config.active = true
+          config.name = "My app"
+          config.push_api_key = "key"
+        end
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("my_env")
+        expect(Appsignal.config[:active]).to be(true)
+        expect(Appsignal.config[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "loads a new config if the env is not the same" do
+        Appsignal._config = Appsignal::Config.new(
+          project_fixture_path,
+          :my_env,
+          :name => "Some name",
+          :push_api_key => "Some key",
+          :ignore_actions => ["My action"]
+        )
+
+        Appsignal.configure(:my_env2) do |config|
+          expect(config.ignore_actions).to be_empty
+          config.active = true
+          config.name = "My app"
+          config.push_api_key = "key"
+        end
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("my_env2")
+        expect(Appsignal.config[:active]).to be(true)
+        expect(Appsignal.config[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "calls configure if not started yet" do
+        Appsignal.configure(:my_env) do |config|
+          config.active = false
+          config.name = "Some name"
+        end
+        Appsignal.start
+        expect(Appsignal.started?).to be_falsy
+
+        Appsignal.configure(:my_env) do |config|
+          expect(config.ignore_actions).to be_empty
+          config.active = true
+          config.name = "My app"
+          config.push_api_key = "key"
+        end
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("my_env")
+        expect(Appsignal.config[:active]).to be(true)
+        expect(Appsignal.config[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+    end
+
+    context "when not active" do
+      it "starts with the configured config" do
+        Appsignal.configure(:test) do |config|
+          config.push_api_key = "key"
+        end
+
+        Appsignal.start
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "uses the given env" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        Appsignal.configure(:env_arg)
+
+        Appsignal.start
+        expect(Appsignal.config.env).to eq("env_arg")
+      end
+
+      it "loads the config without a block being given" do
+        Dir.chdir project_fixture_path do
+          Appsignal.configure(:test)
+        end
+
+        expect(Appsignal.config.env).to eq("test")
+        expect(Appsignal.config[:push_api_key]).to eq("abc")
+      end
+
+      it "allows customization of config in the block" do
+        Appsignal.configure(:test) do |config|
+          config.push_api_key = "key"
+        end
+
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("test")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "loads the default config" do
+        Appsignal.configure do |config|
+          Appsignal::Config::DEFAULT_CONFIG.each do |option, value|
+            expect(config.send(option)).to eq(value)
+          end
+        end
+      end
+
+      it "loads the config from the YAML file" do
+        Dir.chdir project_fixture_path do
+          Appsignal.configure(:test) do |config|
+            expect(config.name).to eq("TestApp")
+          end
+        end
+      end
+
+      it "recognizes valid config" do
+        Appsignal.configure(:my_env) do |config|
+          config.push_api_key = "key"
+        end
+
+        expect(Appsignal.config.valid?).to be(true)
+      end
+
+      it "recognizes invalid config" do
+        Appsignal.configure(:my_env) do |config|
+          config.push_api_key = ""
+        end
+
+        expect(Appsignal.config.valid?).to be(false)
+      end
+
+      it "sets the environment when given as an argument" do
+        Appsignal.configure(:my_env)
+
+        expect(Appsignal.config.env).to eq("my_env")
+      end
+
+      it "reads the environment from the environment" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        Appsignal.configure do |config|
+          expect(config.env).to eq("env_env")
+        end
+
+        expect(Appsignal.config.env).to eq("env_env")
+      end
+
+      it "allows modification of previously unset config options" do
+        expect do
+          Appsignal.configure do |config|
+            config.ignore_actions << "My action"
+            config.request_headers << "My allowed header"
+          end
+        end.to_not(change { Appsignal::Config::DEFAULT_CONFIG })
+
+        expect(Appsignal.config[:ignore_actions]).to eq(["My action"])
+        expect(Appsignal.config[:request_headers])
+          .to eq(Appsignal::Config::DEFAULT_CONFIG[:request_headers] + ["My allowed header"])
+      end
+    end
   end
 
   describe ".start" do
@@ -50,7 +254,7 @@ describe Appsignal do
     end
 
     context "when config is loaded" do
-      before { Appsignal.config = project_fixture_config }
+      before { Appsignal._config = project_fixture_config }
 
       it "should initialize logging" do
         Appsignal.start
@@ -113,6 +317,27 @@ describe Appsignal do
         end
       end
 
+      describe "loaders" do
+        it "starts loaded loaders" do
+          Appsignal::Testing.store[:loader_loaded] = 0
+          Appsignal::Testing.store[:loader_started] = 0
+          define_loader(:start_loader) do
+            def on_load
+              Appsignal::Testing.store[:loader_loaded] += 1
+            end
+
+            def on_start
+              Appsignal::Testing.store[:loader_started] += 1
+            end
+          end
+          Appsignal::Loaders.load(:start_loader)
+          Appsignal::Loaders.start
+
+          expect(Appsignal::Testing.store[:loader_loaded]).to eq(1)
+          expect(Appsignal::Testing.store[:loader_started]).to eq(1)
+        end
+      end
+
       describe "environment metadata" do
         before { capture_environment_metadata_report_calls }
 
@@ -128,7 +353,7 @@ describe Appsignal do
     end
 
     context "with debug logging" do
-      before { Appsignal.config = project_fixture_config("test") }
+      before { Appsignal._config = project_fixture_config("test") }
 
       it "should change the log level" do
         Appsignal.start
@@ -137,6 +362,22 @@ describe Appsignal do
     end
   end
 
+  describe ".load" do
+    before do
+      TestLoader = define_loader(:appsignal_loader)
+    end
+    after do
+      Object.send(:remove_const, :TestLoader)
+    end
+
+    it "loads a loader" do
+      expect(Appsignal::Loaders.instances).to be_empty
+      Appsignal.load(:appsignal_loader)
+      expect(Appsignal::Loaders.instances)
+        .to include(:appsignal_loader => instance_of(TestLoader))
+    end
+  end
+
   describe ".forked" do
     context "when not active" do
       it "does nothing" do
@@ -148,7 +389,7 @@ describe Appsignal do
 
     context "when active" do
       before do
-        Appsignal.config = project_fixture_config
+        Appsignal._config = project_fixture_config
       end
 
       it "starts the logger and extension" do
@@ -162,7 +403,7 @@ describe Appsignal do
 
   describe ".stop" do
     it "calls stop on the extension" do
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping appsignal")
+      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
       expect(Appsignal::Extension).to receive(:stop)
       Appsignal.stop
       expect(Appsignal.active?).to be_falsy
@@ -177,7 +418,7 @@ describe Appsignal do
 
     context "with context specified" do
       it "should log the context" do
-        expect(Appsignal.internal_logger).to receive(:debug).with("Stopping appsignal (something)")
+        expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal (something)")
         expect(Appsignal::Extension).to receive(:stop)
         Appsignal.stop("something")
         expect(Appsignal.active?).to be_falsy
@@ -185,20 +426,34 @@ describe Appsignal do
     end
   end
 
-  describe ".active?" do
-    subject { Appsignal.active? }
+  describe ".started?" do
+    subject { Appsignal.started? }
 
-    context "without config" do
+    context "when started with active config" do
+      before { start_agent }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when started with inactive config" do
       before do
-        Appsignal.config = nil
+        Appsignal._config = project_fixture_config("nonsense")
       end
 
       it { is_expected.to be_falsy }
     end
+  end
+
+  describe ".active?" do
+    subject { Appsignal.active? }
+
+    context "without config" do
+      it { is_expected.to be_falsy }
+    end
 
     context "with inactive config" do
       before do
-        Appsignal.config = project_fixture_config("nonsense")
+        Appsignal._config = project_fixture_config("nonsense")
       end
 
       it { is_expected.to be_falsy }
@@ -206,7 +461,7 @@ describe Appsignal do
 
     context "with active config" do
       before do
-        Appsignal.config = project_fixture_config
+        Appsignal._config = project_fixture_config
       end
 
       it { is_expected.to be_truthy }
@@ -232,7 +487,7 @@ describe Appsignal do
   end
 
   context "not active" do
-    before { Appsignal.config = project_fixture_config("not_active") }
+    before { Appsignal._config = project_fixture_config("not_active") }
 
     describe ".monitor_transaction" do
       it "does not create a transaction" do
@@ -358,7 +613,178 @@ describe Appsignal do
     before { start_agent }
     around { |example| keep_transactions { example.run } }
 
+    describe ".monitor" do
+      it "creates a transaction" do
+        expect do
+          Appsignal.monitor(:action => "MyAction")
+        end.to(change { created_transactions.count }.by(1))
+
+        transaction = last_transaction
+        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        expect(transaction).to have_action("MyAction")
+        expect(transaction).to_not have_error
+        expect(transaction).to_not include_events
+        expect(transaction).to_not have_queue_start
+        expect(transaction).to be_completed
+      end
+
+      it "returns the block's return value" do
+        expect(Appsignal.monitor(:action => nil) { :return_value }).to eq(:return_value)
+      end
+
+      it "sets a custom namespace via the namespace argument" do
+        Appsignal.monitor(:namespace => "custom", :action => nil)
+
+        expect(last_transaction).to have_namespace("custom")
+      end
+
+      it "doesn't overwrite custom namespace set in the block" do
+        Appsignal.monitor(:namespace => "custom", :action => nil) do
+          Appsignal.set_namespace("more custom")
+        end
+
+        expect(last_transaction).to have_namespace("more custom")
+      end
+
+      it "sets the action via the action argument using a string" do
+        Appsignal.monitor(:action => "custom")
+
+        expect(last_transaction).to have_action("custom")
+      end
+
+      it "sets the action via the action argument using a symbol" do
+        Appsignal.monitor(:action => :custom)
+
+        expect(last_transaction).to have_action("custom")
+      end
+
+      it "doesn't overwrite custom action set in the block" do
+        Appsignal.monitor(:action => "custom") do
+          Appsignal.set_action("more custom")
+        end
+
+        expect(last_transaction).to have_action("more custom")
+      end
+
+      it "doesn't set the action when value is nil" do
+        Appsignal.monitor(:action => nil)
+
+        expect(last_transaction).to_not have_action
+      end
+
+      it "doesn't set the action when value is :set_later" do
+        Appsignal.monitor(:action => :set_later)
+
+        expect(last_transaction).to_not have_action
+      end
+
+      it "reports exceptions that occur in the block" do
+        expect do
+          Appsignal.monitor :action => nil do
+            raise ExampleException, "error message"
+          end
+        end.to raise_error(ExampleException, "error message")
+
+        expect(last_transaction).to have_error("ExampleException", "error message")
+      end
+
+      context "with already active transction" do
+        let(:err_stream) { std_stream }
+        let(:stderr) { err_stream.read }
+        let(:transaction) { http_request_transaction }
+        before do
+          set_current_transaction(transaction)
+          transaction.set_action("My action")
+        end
+
+        it "doesn't create a new transaction" do
+          logs = nil
+          expect do
+            logs =
+              capture_logs do
+                capture_std_streams(std_stream, err_stream) do
+                  Appsignal.monitor(:action => nil)
+                end
+              end
+          end.to_not(change { created_transactions.count })
+
+          warning = "An active transaction around this 'Appsignal.monitor' call."
+          expect(logs).to contains_log(:warn, warning)
+          expect(stderr).to include("appsignal WARNING: #{warning}")
+        end
+
+        it "does not overwrite the parent transaction's namespace" do
+          silence { Appsignal.monitor(:namespace => "custom", :action => nil) }
+
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        end
+
+        it "does not overwrite the parent transaction's action" do
+          silence { Appsignal.monitor(:action => "custom") }
+
+          expect(transaction).to have_action("My action")
+        end
+
+        it "doesn't complete the parent transaction" do
+          silence { Appsignal.monitor(:action => nil) }
+
+          expect(transaction).to_not be_completed
+        end
+      end
+    end
+
+    describe ".monitor_and_stop" do
+      it "calls Appsignal.stop after the block" do
+        allow(Appsignal).to receive(:stop)
+        Appsignal.monitor_and_stop(:namespace => "custom", :action => "My Action")
+
+        transaction = last_transaction
+        expect(transaction).to have_namespace("custom")
+        expect(transaction).to have_action("My Action")
+        expect(transaction).to be_completed
+
+        expect(Appsignal).to have_received(:stop).with("monitor_and_stop")
+      end
+    end
+
     describe ".monitor_transaction" do
+      it "prints a deprecation warning" do
+        err_stream = std_stream
+        capture_std_streams(std_stream, err_stream) do
+          Appsignal.monitor_transaction(
+            "perform_job.something",
+            :class => "BackgroundJob",
+            :method => "perform"
+          ) do
+            :return_value
+          end
+        end
+
+        expect(err_stream.read).to include(
+          "appsignal WARNING: The `Appsignal.monitor_transaction` helper is deprecated."
+        )
+      end
+
+      it "logs a deprecation warning" do
+        logs =
+          capture_logs do
+            silence do
+              Appsignal.monitor_transaction(
+                "perform_job.something",
+                :class => "BackgroundJob",
+                :method => "perform"
+              ) do
+                :return_value
+              end
+            end
+          end
+
+        expect(logs).to contains_log(
+          :warn,
+          "The `Appsignal.monitor_transaction` helper is deprecated."
+        )
+      end
+
       context "with a successful call" do
         it "instruments and completes for a background job" do
           return_value = nil
@@ -368,7 +794,8 @@ describe Appsignal do
                 "perform_job.something",
                 {
                   :class => "BackgroundJob",
-                  :method => "perform"
+                  :method => "perform",
+                  :queue_start => fixed_time.to_i
                 }
               ) do
                 :return_value
@@ -380,6 +807,7 @@ describe Appsignal do
           expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
           expect(transaction).to have_action("BackgroundJob#perform")
           expect(transaction).to include_event("name" => "perform_job.something")
+          expect(transaction).to have_queue_start(1_389_783_600_000)
           expect(transaction).to be_completed
         end
 
@@ -391,7 +819,8 @@ describe Appsignal do
                 "process_action.something",
                 {
                   :controller => "BlogPostsController",
-                  :action => "show"
+                  :action => "show",
+                  "HTTP_X_REQUEST_START" => "t=#{fixed_time.to_i * 1000}"
                 }
               ) do
                 :return_value
@@ -403,6 +832,7 @@ describe Appsignal do
           expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
           expect(transaction).to have_action("BlogPostsController#show")
           expect(transaction).to include_event("name" => "process_action.something")
+          expect(transaction).to have_queue_start(1_389_783_600_000)
           expect(transaction).to be_completed
         end
       end
@@ -444,6 +874,43 @@ describe Appsignal do
     end
 
     describe ".monitor_single_transaction" do
+      it "prints a deprecation warning" do
+        err_stream = std_stream
+        capture_std_streams(std_stream, err_stream) do
+          Appsignal.monitor_single_transaction(
+            "perform_job.something",
+            :class => "BackgroundJob",
+            :method => "perform"
+          ) do
+            :return_value
+          end
+        end
+
+        expect(err_stream.read).to include(
+          "appsignal WARNING: The `Appsignal.monitor_single_transaction` helper is deprecated."
+        )
+      end
+
+      it "logs a deprecation warning" do
+        logs =
+          capture_logs do
+            silence do
+              Appsignal.monitor_single_transaction(
+                "perform_job.something",
+                :class => "BackgroundJob",
+                :method => "perform"
+              ) do
+                :return_value
+              end
+            end
+          end
+
+        expect(logs).to contains_log(
+          :warn,
+          "The `Appsignal.monitor_single_transaction` helper is deprecated."
+        )
+      end
+
       context "with a successful call" do
         it "calls monitor_transaction and Appsignal.stop" do
           expect(Appsignal).to receive(:stop)
@@ -521,9 +988,7 @@ describe Appsignal do
     end
 
     describe ".set_params" do
-      before do
-        start_agent
-      end
+      before { start_agent }
 
       context "with transaction" do
         let(:transaction) { http_request_transaction }
@@ -561,6 +1026,84 @@ describe Appsignal do
       end
     end
 
+    describe ".set_session_data" do
+      before { start_agent }
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets session data on the transaction" do
+          Appsignal.set_session_data("data" => "value1")
+
+          transaction._sample
+          expect(transaction).to include_session_data("data" => "value1")
+        end
+
+        it "overwrites the session data if called multiple times" do
+          Appsignal.set_session_data("data" => "value1")
+          Appsignal.set_session_data("data" => "value2")
+
+          transaction._sample
+          expect(transaction).to include_session_data("data" => "value2")
+        end
+
+        it "sets session data with a block on the transaction" do
+          Appsignal.set_session_data { { "data" => "value1" } }
+
+          transaction._sample
+          expect(transaction).to include_session_data("data" => "value1")
+        end
+      end
+
+      context "without transaction" do
+        it "does not set session data on the transaction" do
+          Appsignal.set_session_data("a" => "b")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_session_data)
+        end
+      end
+    end
+
+    describe ".set_headers" do
+      before { start_agent }
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets request headers on the transaction" do
+          Appsignal.set_headers("PATH_INFO" => "/some-path")
+
+          transaction._sample
+          expect(transaction).to include_environment("PATH_INFO" => "/some-path")
+        end
+
+        it "overwrites the request headers if called multiple times" do
+          Appsignal.set_headers("PATH_INFO" => "/some-path1")
+          Appsignal.set_headers("PATH_INFO" => "/some-path2")
+
+          transaction._sample
+          expect(transaction).to include_environment("PATH_INFO" => "/some-path2")
+        end
+
+        it "sets request headers with a block on the transaction" do
+          Appsignal.set_headers { { "PATH_INFO" => "/some-path" } }
+
+          transaction._sample
+          expect(transaction).to include_environment("PATH_INFO" => "/some-path")
+        end
+      end
+
+      context "without transaction" do
+        it "does not set request headers on the transaction" do
+          Appsignal.set_headers("PATH_INFO" => "/some-path")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_headers)
+        end
+      end
+    end
+
     describe ".set_custom_data" do
       before { start_agent }
 
@@ -595,13 +1138,11 @@ describe Appsignal do
     end
 
     describe ".add_breadcrumb" do
-      around do |example|
-        start_agent
-        with_current_transaction(transaction) { example.run }
-      end
+      before { start_agent }
 
       context "with transaction" do
         let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
 
         it "adds the breadcrumb to the transaction" do
           Appsignal.add_breadcrumb(
@@ -1269,7 +1810,7 @@ describe Appsignal do
       end
     end
 
-    describe ".without_instrumentation" do
+    describe ".ignore_instrumentation_events" do
       around { |example| keep_transactions { example.run } }
       let(:transaction) { http_request_transaction }
 
@@ -1281,20 +1822,44 @@ describe Appsignal do
           expect(transaction).to receive(:resume!).and_call_original
 
           Appsignal.instrument("register.this.event") { :do_nothing }
-          Appsignal.without_instrumentation do
+          Appsignal.ignore_instrumentation_events do
             Appsignal.instrument("dont.register.this.event") { :do_nothing }
           end
 
           expect(transaction).to include_event("name" => "register.this.event")
           expect(transaction).to_not include_event("name" => "dont.register.this.event")
         end
+
+        it "has a without_instrumentation alias that prints a deprecation warning" do
+          Appsignal.instrument("register.this.event") { :do_nothing }
+          err_stream = std_stream
+          logs =
+            capture_logs do
+              capture_std_streams(std_stream, err_stream) do
+                Appsignal.without_instrumentation do
+                  Appsignal.instrument("dont.register.this.event") { :do_nothing }
+                end
+              end
+            end
+
+          expect(transaction).to include_event("name" => "register.this.event")
+          expect(transaction).to_not include_event("name" => "dont.register.this.event")
+
+          expect(logs).to contains_log(
+            :warn,
+            "The `Appsignal.without_instrumentation` helper is deprecated."
+          )
+          expect(err_stream.read).to include(
+            "appsignal WARNING: The `Appsignal.without_instrumentation` helper is deprecated."
+          )
+        end
       end
 
       context "without current transaction" do
         let(:transaction) { nil }
 
         it "does not crash" do
-          Appsignal.without_instrumentation { :do_nothing }
+          Appsignal.ignore_instrumentation_events { :do_nothing }
         end
       end
     end
@@ -1312,8 +1877,9 @@ describe Appsignal do
           Appsignal.start_logger
         end
       end
-      expect(stderr).to include("appsignal WARNING: Callng 'Appsignal.start_logger' is deprecated.")
-      expect(log).to contains_log(:warn, "Callng 'Appsignal.start_logger' is deprecated.")
+      expect(stderr)
+        .to include("appsignal WARNING: Calling 'Appsignal.start_logger' is deprecated.")
+      expect(log).to contains_log(:warn, "Calling 'Appsignal.start_logger' is deprecated.")
     end
   end
 
@@ -1335,7 +1901,7 @@ describe Appsignal do
     after { FileUtils.rm_rf(log_path) }
 
     def initialize_config
-      Appsignal.config = project_fixture_config(
+      Appsignal._config = project_fixture_config(
         "production",
         :log_path => log_path,
         :log_level => log_level
@@ -1482,7 +2048,6 @@ describe Appsignal do
 
       context "when there is no config" do
         before do
-          Appsignal.config = nil
           capture_stdout(out_stream) do
             Appsignal._start_logger
           end