appsignal 3.13.0-java → 4.0.0.beta.2-java

data/spec/lib/appsignal_spec.rb

@@ -4,34 +4,6 @@ describe Appsignal do
 
   let(:transaction) { http_request_transaction }
 
-  describe ".config=" do
-    it "sets the config" do
-      config = project_fixture_config
-      expect(Appsignal.internal_logger).to_not receive(:level=)
-
-      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
@@ -62,11 +34,9 @@ describe Appsignal do
 
     context "with config but not started" do
       it "reuses the already loaded config if no env arg is given" do
-        Appsignal._config = Appsignal::Config.new(
-          project_fixture_path,
-          :my_env,
-          :ignore_actions => ["My action"]
-        )
+        Appsignal.configure(:my_env, :root_path => project_fixture_path) do |config|
+          config.ignore_actions = ["My action"]
+        end
 
         Appsignal.configure do |config|
           expect(config.env).to eq("my_env")
@@ -76,6 +46,8 @@ describe Appsignal do
           config.name = "My app"
           config.push_api_key = "key"
         end
+        Appsignal.start
+
         expect(Appsignal.config.valid?).to be(true)
         expect(Appsignal.config.env).to eq("my_env")
         expect(Appsignal.config[:name]).to eq("My app")
@@ -84,11 +56,9 @@ describe Appsignal do
       end
 
       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, :root_path => project_fixture_path) do |config|
+          config.ignore_actions = ["My action"]
+        end
 
         Appsignal.configure(:my_env) do |config|
           expect(config.ignore_actions).to eq(["My action"])
@@ -96,6 +66,8 @@ describe Appsignal do
           config.name = "My app"
           config.push_api_key = "key"
         end
+        Appsignal.start
+
         expect(Appsignal.config.valid?).to be(true)
         expect(Appsignal.config.env).to eq("my_env")
         expect(Appsignal.config[:active]).to be(true)
@@ -104,13 +76,11 @@ describe Appsignal do
       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_env, :root_path => project_fixture_path) do |config|
+          config.name = "Some name"
+          config.push_api_key = "Some key"
+          config.ignore_actions = ["My action"]
+        end
 
         Appsignal.configure(:my_env2) do |config|
           expect(config.ignore_actions).to be_empty
@@ -118,6 +88,8 @@ describe Appsignal do
           config.name = "My app"
           config.push_api_key = "key"
         end
+        Appsignal.start
+
         expect(Appsignal.config.valid?).to be(true)
         expect(Appsignal.config.env).to eq("my_env2")
         expect(Appsignal.config[:active]).to be(true)
@@ -126,13 +98,11 @@ describe Appsignal do
       end
 
       it "loads a new config if the path is not the same" do
-        Appsignal._config = Appsignal::Config.new(
-          "/some/path",
-          :my_env,
-          :name => "Some name",
-          :push_api_key => "Some key",
-          :ignore_actions => ["My action"]
-        )
+        Appsignal.configure(:my_env, :root_path => "/some/path") do |config|
+          config.name = "Some name"
+          config.push_api_key = "Some key"
+          config.ignore_actions = ["My action"]
+        end
 
         Appsignal.configure(:my_env, :root_path => project_fixture_path) do |config|
           expect(config.ignore_actions).to be_empty
@@ -140,6 +110,8 @@ describe Appsignal do
           config.name = "My app"
           config.push_api_key = "key"
         end
+        Appsignal.start
+
         expect(Appsignal.config.valid?).to be(true)
         expect(Appsignal.config.env).to eq("my_env")
         expect(Appsignal.config[:active]).to be(true)
@@ -161,6 +133,8 @@ describe Appsignal do
           config.name = "My app"
           config.push_api_key = "key"
         end
+        Appsignal.start
+
         expect(Appsignal.config.valid?).to be(true)
         expect(Appsignal.config.env).to eq("my_env")
         expect(Appsignal.config[:active]).to be(true)
@@ -174,23 +148,23 @@ describe Appsignal 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 "uses the given root path to read the config file" do
         Appsignal.configure(:test, :root_path => project_fixture_path)
-
         Appsignal.start
+
         expect(Appsignal.config.env).to eq("test")
         expect(Appsignal.config[:push_api_key]).to eq("abc")
         # Ensure it loads from the config file in the given path
@@ -201,6 +175,7 @@ describe Appsignal do
         Dir.chdir project_fixture_path do
           Appsignal.configure(:test)
         end
+        Appsignal.start
 
         expect(Appsignal.config.env).to eq("test")
         expect(Appsignal.config[:push_api_key]).to eq("abc")
@@ -212,6 +187,7 @@ describe Appsignal do
         Appsignal.configure(:test) do |config|
           config.push_api_key = "key"
         end
+        Appsignal.start
 
         expect(Appsignal.config.valid?).to be(true)
         expect(Appsignal.config.env).to eq("test")
@@ -238,6 +214,7 @@ describe Appsignal do
         Appsignal.configure(:my_env) do |config|
           config.push_api_key = "key"
         end
+        Appsignal.start
 
         expect(Appsignal.config.valid?).to be(true)
       end
@@ -246,6 +223,7 @@ describe Appsignal do
         Appsignal.configure(:my_env) do |config|
           config.push_api_key = ""
         end
+        Appsignal.start
 
         expect(Appsignal.config.valid?).to be(false)
       end
@@ -398,7 +376,7 @@ describe Appsignal do
     end
 
     context "when config is loaded" do
-      before { Appsignal._config = project_fixture_config }
+      before { Appsignal.configure(:production, :root_path => project_fixture_path) }
 
       it "should initialize logging" do
         Appsignal.start
@@ -410,6 +388,27 @@ describe Appsignal do
         Appsignal.start
       end
 
+      it "freezes the config" do
+        Appsignal.start
+
+        expect_frozen_error do
+          Appsignal.config[:ignore_actions] << "my action"
+        end
+        expect_frozen_error do
+          Appsignal.config.config_hash[:ignore_actions] << "my action"
+        end
+        expect_frozen_error do
+          Appsignal.config.config_hash.merge!(:option => :value)
+        end
+        expect_frozen_error do
+          Appsignal.config[:ignore_actions] = "my action"
+        end
+      end
+
+      def expect_frozen_error(&block)
+        expect(&block).to raise_error(FrozenError)
+      end
+
       context "when allocation tracking has been enabled" do
         before do
           Appsignal.config.config_hash[:enable_allocation_tracking] = true
@@ -496,8 +495,21 @@ describe Appsignal do
       end
     end
 
+    context "when already started" do
+      it "doesn't start again" do
+        start_agent
+
+        expect(Appsignal::Extension).to_not receive(:start)
+        logs = capture_logs { Appsignal.start }
+        expect(logs).to contains_log(
+          :warn,
+          "Ignoring call to Appsignal.start after AppSignal has started"
+        )
+      end
+    end
+
     context "with debug logging" do
-      before { Appsignal._config = project_fixture_config("test") }
+      before { Appsignal.configure(:test, :root_path => project_fixture_path) }
 
       it "should change the log level" do
         Appsignal.start
@@ -533,7 +545,8 @@ describe Appsignal do
 
     context "when active" do
       before do
-        Appsignal._config = project_fixture_config
+        Appsignal.configure(:production, :root_path => project_fixture_path)
+        Appsignal.start
       end
 
       it "starts the logger and extension" do
@@ -580,9 +593,7 @@ describe Appsignal do
     end
 
     context "when started with inactive config" do
-      before do
-        Appsignal._config = project_fixture_config("nonsense")
-      end
+      before { Appsignal.configure(:nonsense, :root_path => project_fixture_path) }
 
       it { is_expected.to be_falsy }
     end
@@ -597,7 +608,8 @@ describe Appsignal do
 
     context "with inactive config" do
       before do
-        Appsignal._config = project_fixture_config("nonsense")
+        Appsignal.configure(:nonsense, :root_path => project_fixture_path)
+        Appsignal.start
       end
 
       it { is_expected.to be_falsy }
@@ -605,7 +617,8 @@ describe Appsignal do
 
     context "with active config" do
       before do
-        Appsignal._config = project_fixture_config
+        Appsignal.configure(:production, :root_path => project_fixture_path)
+        Appsignal.start
       end
 
       it { is_expected.to be_truthy }
@@ -631,65 +644,9 @@ describe Appsignal do
   end
 
   context "not active" do
-    before { Appsignal._config = project_fixture_config("not_active") }
-
-    describe ".monitor_transaction" do
-      it "does not create a transaction" do
-        object = double(:some_method => 1)
-
-        expect do
-          Appsignal.monitor_transaction("perform_job.nothing") do
-            object.some_method
-          end
-        end.to_not(change { created_transactions.count })
-      end
-
-      it "returns the block's return value" do
-        object = double(:some_method => 1)
-
-        return_value = Appsignal.monitor_transaction("perform_job.nothing") do
-          object.some_method
-        end
-        expect(return_value).to eq 1
-      end
-
-      context "with an unknown event type" do
-        it "yields the given block" do
-          expect do |blk|
-            Appsignal.monitor_transaction("unknown.sidekiq", &blk)
-          end.to yield_control
-        end
-
-        it "logs an error" do
-          logs =
-            capture_logs do
-              Appsignal.monitor_transaction("unknown.sidekiq") {} # rubocop:disable Lint/EmptyBlock
-            end
-          expect(logs).to contains_log(
-            :error,
-            "Unrecognized name 'unknown.sidekiq': names must start with either 'perform_job' " \
-              "(for jobs and tasks) or 'process_action' (for HTTP requests)"
-          )
-        end
-      end
-    end
-
-    describe ".listen_for_error" do
-      let(:error) { ExampleException.new("specific error") }
-
-      it "reraises the error" do
-        expect do
-          Appsignal.listen_for_error { raise error }
-        end.to raise_error(error)
-      end
-
-      it "does not create a transaction" do
-        expect do
-          expect do
-            Appsignal.listen_for_error { raise error }
-          end.to raise_error(error)
-        end.to_not(change { created_transactions.count })
-      end
+    before do
+      Appsignal.configure(:not_active, :root_path => project_fixture_path)
+      Appsignal.start
     end
 
     describe ".send_error" do
@@ -852,7 +809,7 @@ describe Appsignal do
               end
           end.to_not(change { created_transactions.count })
 
-          warning = "An active transaction around this 'Appsignal.monitor' call."
+          warning = "A transaction is active around this 'Appsignal.monitor' call."
           expect(logs).to contains_log(:warn, warning)
           expect(stderr).to include("appsignal WARNING: #{warning}")
         end
@@ -897,211 +854,6 @@ describe Appsignal do
       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
-          expect do
-            return_value =
-              Appsignal.monitor_transaction(
-                "perform_job.something",
-                {
-                  :class => "BackgroundJob",
-                  :method => "perform",
-                  :queue_start => fixed_time.to_i
-                }
-              ) do
-                :return_value
-              end
-          end.to(change { created_transactions.count }.by(1))
-          expect(return_value).to eq(:return_value)
-
-          transaction = last_transaction
-          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
-
-        it "instruments and completes for a http request" do
-          return_value = nil
-          expect do
-            return_value =
-              Appsignal.monitor_transaction(
-                "process_action.something",
-                {
-                  :controller => "BlogPostsController",
-                  :action => "show",
-                  "HTTP_X_REQUEST_START" => "t=#{fixed_time.to_i * 1000}"
-                }
-              ) do
-                :return_value
-              end
-          end.to(change { created_transactions.count }.by(1))
-          expect(return_value).to eq(:return_value)
-
-          transaction = last_transaction
-          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
-
-      context "with an erroring call" do
-        let(:error) { ExampleException.new("error message") }
-
-        it "adds the error to the current transaction and complete" do
-          expect do
-            Appsignal.monitor_transaction("perform_job.something") do
-              raise error
-            end
-          end.to raise_error(error)
-
-          expect(last_transaction).to have_error("ExampleException", "error message")
-          expect(last_transaction).to be_completed
-        end
-      end
-
-      context "with an unknown event type" do
-        it "yields the given block" do
-          expect do |blk|
-            Appsignal.monitor_transaction("unknown.sidekiq", &blk)
-          end.to yield_control
-        end
-
-        it "logs an error" do
-          logs =
-            capture_logs do
-              Appsignal.monitor_transaction("unknown.sidekiq") {} # rubocop:disable Lint/EmptyBlock
-            end
-          expect(logs).to contains_log(
-            :error,
-            "Unrecognized name 'unknown.sidekiq': names must start with either 'perform_job' " \
-              "(for jobs and tasks) or 'process_action' (for HTTP requests)"
-          )
-        end
-      end
-    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)
-
-          Appsignal.monitor_single_transaction(
-            "perform_job.something",
-            :controller => :my_controller,
-            :action => :my_action
-          ) do
-            # nothing
-          end
-
-          transaction = last_transaction
-          expect(transaction).to have_action("my_controller#my_action")
-          expect(transaction).to include_event("name" => "perform_job.something")
-        end
-      end
-
-      context "with an erroring call" do
-        let(:error) { ExampleException.new }
-
-        it "calls monitor_transaction and stop and re-raises the error" do
-          expect(Appsignal).to receive(:stop)
-
-          expect do
-            Appsignal.monitor_single_transaction(
-              "perform_job.something",
-              :controller => :my_controller,
-              :action => :my_action
-            ) do
-              raise error
-            end
-          end.to raise_error(error)
-
-          transaction = last_transaction
-          expect(transaction).to have_action("my_controller#my_action")
-          expect(transaction).to include_event("name" => "perform_job.something")
-        end
-      end
-    end
-
     describe ".tag_request" do
       before { start_agent }
 
@@ -1137,30 +889,37 @@ describe Appsignal do
       end
     end
 
-    describe ".set_params" do
+    describe ".add_params" do
       before { start_agent }
 
+      it "has a .set_params alias" do
+        expect(Appsignal.method(:add_params)).to eq(Appsignal.method(:set_params))
+      end
+
       context "with transaction" do
         let(:transaction) { http_request_transaction }
         before { set_current_transaction(transaction) }
 
-        it "sets parameters on the transaction" do
-          Appsignal.set_params("param1" => "value1")
+        it "adds parameters to the transaction" do
+          Appsignal.add_params("param1" => "value1")
 
           transaction._sample
           expect(transaction).to include_params("param1" => "value1")
         end
 
-        it "overwrites the params if called multiple times" do
-          Appsignal.set_params("param1" => "value1")
-          Appsignal.set_params("param2" => "value2")
+        it "merges the params if called multiple times" do
+          Appsignal.add_params("param1" => "value1")
+          Appsignal.add_params("param2" => "value2")
 
           transaction._sample
-          expect(transaction).to include_params("param2" => "value2")
+          expect(transaction).to include_params(
+            "param1" => "value1",
+            "param2" => "value2"
+          )
         end
 
-        it "sets parameters with a block on the transaction" do
-          Appsignal.set_params { { "param1" => "value1" } }
+        it "adds parameters with a block to the transaction" do
+          Appsignal.add_params { { "param1" => "value1" } }
 
           transaction._sample
           expect(transaction).to include_params("param1" => "value1")
@@ -1168,37 +927,61 @@ describe Appsignal do
       end
 
       context "without transaction" do
-        it "does not set tags on the transaction" do
-          Appsignal.set_params("a" => "b")
+        it "does not add tags to any transaction" do
+          Appsignal.add_params("a" => "b")
 
-          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_params)
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:add_params)
         end
       end
     end
 
-    describe ".set_session_data" do
+    describe ".set_empty_params!" 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")
+        it "marks parameters to be sent as an empty value" do
+          Appsignal.add_params("key1" => "value")
+          Appsignal.set_empty_params!
+
+          transaction._sample
+          expect(transaction).to_not include_params
+        end
+      end
+    end
+
+    describe ".add_session_data" do
+      before { start_agent }
+
+      it "has a .set_session_data alias" do
+        expect(Appsignal.method(:add_session_data)).to eq(Appsignal.method(:set_session_data))
+      end
+
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "adds session data to the transaction" do
+          Appsignal.add_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")
+        it "merges the session data if called multiple times" do
+          Appsignal.set_session_data("data1" => "value1")
+          Appsignal.set_session_data("data2" => "value2")
 
           transaction._sample
-          expect(transaction).to include_session_data("data" => "value2")
+          expect(transaction).to include_session_data(
+            "data1" => "value1",
+            "data2" => "value2"
+          )
         end
 
-        it "sets session data with a block on the transaction" do
+        it "adds session data with a block to the transaction" do
           Appsignal.set_session_data { { "data" => "value1" } }
 
           transaction._sample
@@ -1207,38 +990,45 @@ describe Appsignal do
       end
 
       context "without transaction" do
-        it "does not set session data on the transaction" do
+        it "does not add session data to any transaction" do
           Appsignal.set_session_data("a" => "b")
 
-          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_session_data)
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:add_session_data)
         end
       end
     end
 
-    describe ".set_headers" do
+    describe ".add_headers" do
       before { start_agent }
 
+      it "has a .set_headers alias" do
+        expect(Appsignal.method(:add_headers)).to eq(Appsignal.method(:set_headers))
+      end
+
       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")
+        it "adds request headers to the transaction" do
+          Appsignal.add_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")
+        it "merges the request headers if called multiple times" do
+          Appsignal.add_headers("PATH_INFO" => "/some-path")
+          Appsignal.add_headers("REQUEST_METHOD" => "GET")
 
           transaction._sample
-          expect(transaction).to include_environment("PATH_INFO" => "/some-path2")
+          expect(transaction).to include_environment(
+            "PATH_INFO" => "/some-path",
+            "REQUEST_METHOD" => "GET"
+          )
         end
 
-        it "sets request headers with a block on the transaction" do
-          Appsignal.set_headers { { "PATH_INFO" => "/some-path" } }
+        it "adds request headers with a block to the transaction" do
+          Appsignal.add_headers { { "PATH_INFO" => "/some-path" } }
 
           transaction._sample
           expect(transaction).to include_environment("PATH_INFO" => "/some-path")
@@ -1246,23 +1036,27 @@ describe Appsignal do
       end
 
       context "without transaction" do
-        it "does not set request headers on the transaction" do
-          Appsignal.set_headers("PATH_INFO" => "/some-path")
+        it "does not add request headers to any transaction" do
+          Appsignal.add_headers("PATH_INFO" => "/some-path")
 
-          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_headers)
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:add_headers)
         end
       end
     end
 
-    describe ".set_custom_data" do
+    describe ".add_custom_data" do
       before { start_agent }
 
+      it "has a .set_custom_data alias" do
+        expect(Appsignal.method(:add_custom_data)).to eq(Appsignal.method(:set_custom_data))
+      end
+
       context "with transaction" do
         let(:transaction) { http_request_transaction }
         before { set_current_transaction transaction }
 
-        it "sets custom data on the current transaction" do
-          Appsignal.set_custom_data(
+        it "adds custom data to the current transaction" do
+          Appsignal.add_custom_data(
             :user => { :id => 123 },
             :organization => { :slug => "appsignal" }
           )
@@ -1273,16 +1067,27 @@ describe Appsignal do
             "organization" => { "slug" => "appsignal" }
           )
         end
+
+        it "merges the custom data if called multiple times" do
+          Appsignal.add_custom_data(:abc => "value")
+          Appsignal.add_custom_data(:def => "value")
+
+          transaction._sample
+          expect(transaction).to include_custom_data(
+            "abc" => "value",
+            "def" => "value"
+          )
+        end
       end
 
       context "without transaction" do
-        it "does not set tags on the transaction" do
-          Appsignal.set_custom_data(
+        it "does not add tags any the transaction" do
+          Appsignal.add_custom_data(
             :user => { :id => 123 },
             :organization => { :slug => "appsignal" }
           )
 
-          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_custom_data)
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:add_custom_data)
         end
       end
     end
@@ -1323,7 +1128,7 @@ describe Appsignal do
       end
     end
 
-    describe "custom stats" do
+    describe "custom metrics" do
       let(:tags) { { :foo => "bar" } }
 
       describe ".set_gauge" do
@@ -1358,50 +1163,6 @@ describe Appsignal do
         end
       end
 
-      describe ".set_host_gauge" do
-        let(:err_stream) { std_stream }
-        let(:stderr) { err_stream.read }
-        let(:log_stream) { StringIO.new }
-        let(:logs) { log_contents(log_stream) }
-        let(:deprecation_message) do
-          "The `set_host_gauge` method has been deprecated. " \
-            "Calling this method has no effect. " \
-            "Please remove method call in the following file to remove " \
-            "this message."
-        end
-        before do
-          Appsignal.internal_logger = test_logger(log_stream)
-          capture_std_streams(std_stream, err_stream) { Appsignal.set_host_gauge("key", 0.1) }
-        end
-
-        it "logs a deprecation warning" do
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to include(deprecation_message)
-        end
-      end
-
-      describe ".set_process_gauge" do
-        let(:err_stream) { std_stream }
-        let(:stderr) { err_stream.read }
-        let(:log_stream) { StringIO.new }
-        let(:logs) { log_contents(log_stream) }
-        let(:deprecation_message) do
-          "The `set_process_gauge` method has been deprecated. " \
-            "Calling this method has no effect. " \
-            "Please remove method call in the following file to remove " \
-            "this message."
-        end
-        before do
-          Appsignal.internal_logger = test_logger(log_stream)
-          capture_std_streams(std_stream, err_stream) { Appsignal.set_process_gauge("key", 0.1) }
-        end
-
-        it "logs a deprecation warning" do
-          expect(stderr).to include("appsignal WARNING: #{deprecation_message}")
-          expect(logs).to include(deprecation_message)
-        end
-      end
-
       describe ".increment_counter" do
         it "should call increment_counter on the extension with a string key" do
           expect(Appsignal::Extension).to receive(:increment_counter)
@@ -1537,138 +1298,52 @@ describe Appsignal do
         end
       end
 
-      context "with tags" do
-        let(:tags) { { :a => "a", :b => "b" } }
-
-        it "prints a deprecation warning and tags the transaction" do
-          logs = capture_logs do
-            expect do
-              capture_std_streams(std_stream, err_stream) do
-                Appsignal.send_error(error, tags)
-              end
-            end.to change { created_transactions.count }.by(1)
+      context "when given a block" do
+        it "yields the transaction and allows additional metadata to be set" do
+          Appsignal.send_error(StandardError.new("my_error")) do |transaction|
+            transaction.set_action("my_action")
+            transaction.set_namespace("my_namespace")
           end
 
-          expect(last_transaction).to include_tags("a" => "a", "b" => "b")
-
-          message = "The tags argument for `Appsignal.send_error` is deprecated. " \
-            "Please use the block method to set tags instead.\n\n" \
-            "  Appsignal.send_error(error) do |transaction|\n" \
-            "    transaction.set_tags(#{tags.inspect})\n" \
-            "  end\n\n" \
-            "Appsignal.send_error called on location: #{__FILE__}:"
-          expect(stderr).to include("appsignal WARNING: #{message}")
-          expect(logs).to include(message)
+          expect(last_transaction).to have_namespace("my_namespace")
+          expect(last_transaction).to have_action("my_action")
+          expect(last_transaction).to have_error("StandardError", "my_error")
         end
-      end
 
-      context "with namespace" do
-        let(:namespace) { "admin" }
-
-        it "prints a deprecation warning and sets the namespace on the transaction" do
-          logs = capture_logs do
-            expect do
-              capture_std_streams(std_stream, err_stream) do
-                Appsignal.send_error(error, nil, namespace)
-              end
-            end.to change { created_transactions.count }.by(1)
+        it "yields and allows additional metadata to be set with global helpers" do
+          Appsignal.send_error(StandardError.new("my_error")) do
+            Appsignal.set_action("my_action")
+            Appsignal.set_namespace("my_namespace")
           end
 
-          expect(last_transaction).to have_namespace(namespace)
-
-          message = "The namespace argument for `Appsignal.send_error` is deprecated. " \
-            "Please use the block method to set the namespace instead.\n\n" \
-            "  Appsignal.send_error(error) do |transaction|\n" \
-            "    transaction.set_namespace(#{namespace.inspect})\n" \
-            "  end\n\n" \
-            "Appsignal.send_error called on location: #{__FILE__}:"
-          expect(stderr).to include("appsignal WARNING: #{message}")
-          expect(logs).to include(message)
-        end
-      end
-
-      context "when given a block" do
-        it "yields the transaction and allows additional metadata to be set" do
-          keep_transactions do
-            Appsignal.send_error(StandardError.new("my_error")) do |transaction|
-              transaction.set_action("my_action")
-              transaction.set_namespace("my_namespace")
-            end
-          end
           expect(last_transaction).to have_namespace("my_namespace")
           expect(last_transaction).to have_action("my_action")
           expect(last_transaction).to have_error("StandardError", "my_error")
         end
-      end
-    end
 
-    describe ".listen_for_error" do
-      around { |example| keep_transactions { example.run } }
+        it "yields to set metadata and doesn't modify the active transaction" do
+          active_transaction = http_request_transaction
+          active_transaction.set_action("active action")
+          active_transaction.set_namespace("active namespace")
+          set_current_transaction(active_transaction)
+          expect(current_transaction).to eq(active_transaction)
 
-      it "prints and logs a deprecation warning" do
-        err_stream = std_stream
-        logs =
-          capture_logs do
-            capture_std_streams(std_stream, err_stream) do
-              Appsignal.listen_for_error do
-                # Do nothing
-              end
-            end
+          Appsignal.send_error(StandardError.new("my_error")) do
+            Appsignal.set_action("my_action")
+            Appsignal.set_namespace("my_namespace")
           end
-        expect(err_stream.read)
-          .to include("appsignal WARNING: The `Appsignal.listen_for_error` helper is deprecated.")
-        expect(logs).to contains_log(
-          :warn,
-          "The `Appsignal.listen_for_error` helper is deprecated."
-        )
-      end
 
-      it "records the error and re-raise it" do
-        expect do
-          expect do
-            Appsignal.listen_for_error do
-              raise ExampleException, "I am an exception"
-            end
-          end.to raise_error(ExampleException, "I am an exception")
-        end.to change { created_transactions.count }.by(1)
-
-        # Default namespace
-        expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        expect(last_transaction).to have_error("ExampleException", "I am an exception")
-        expect(last_transaction).to_not include_tags
-      end
-
-      context "with tags" do
-        it "adds tags to the transaction" do
-          expect do
-            expect do
-              Appsignal.listen_for_error("foo" => "bar") do
-                raise ExampleException, "I am an exception"
-              end
-            end.to raise_error(ExampleException, "I am an exception")
-          end.to change { created_transactions.count }.by(1)
-
-          # Default namespace
-          expect(last_transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-          expect(last_transaction).to have_error("ExampleException", "I am an exception")
-          expect(last_transaction).to include_tags("foo" => "bar")
-        end
-      end
+          # Restores the active_transaction as the current transaction
+          expect(current_transaction).to eq(active_transaction)
 
-      context "with a custom namespace" do
-        it "adds the namespace to the transaction" do
-          expect do
-            expect do
-              Appsignal.listen_for_error(nil, "custom_namespace") do
-                raise ExampleException, "I am an exception"
-              end
-            end.to raise_error(ExampleException, "I am an exception")
-          end.to change { created_transactions.count }.by(1)
+          expect(last_transaction).to have_namespace("my_namespace")
+          expect(last_transaction).to have_action("my_action")
+          expect(last_transaction).to have_error("StandardError", "my_error")
+          expect(last_transaction).to be_completed
 
-          # Default namespace
-          expect(last_transaction).to have_namespace("custom_namespace")
-          expect(last_transaction).to have_error("ExampleException", "I am an exception")
-          expect(last_transaction).to_not include_tags
+          expect(active_transaction).to have_namespace("active namespace")
+          expect(active_transaction).to have_action("active action")
+          expect(active_transaction).to_not be_completed
         end
       end
     end
@@ -1713,68 +1388,6 @@ describe Appsignal do
           end
         end
 
-        context "with tags" do
-          let(:tags) { { "foo" => "bar" } }
-
-          it "tags the transaction" do
-            silence(:allowed => ["set_error", "The tags argument for"]) do
-              Appsignal.set_error(error, tags)
-            end
-
-            transaction._sample
-            expect(transaction).to have_error(error)
-            expect(transaction).to include_tags(tags)
-          end
-
-          it "prints a deprecation warning and tags the transaction" do
-            logs = capture_logs do
-              capture_std_streams(std_stream, err_stream) do
-                Appsignal.set_error(error, tags)
-              end
-            end
-
-            message = "The tags argument for `Appsignal.set_error` is deprecated. " \
-              "Please use the block method to set tags instead.\n\n" \
-              "  Appsignal.set_error(error) do |transaction|\n" \
-              "    transaction.set_tags(#{tags.inspect})\n" \
-              "  end\n\n" \
-              "Appsignal.set_error called on location: #{__FILE__}:"
-            expect(stderr).to include("appsignal WARNING: #{message}")
-            expect(logs).to include(message)
-          end
-        end
-
-        context "with namespace" do
-          let(:namespace) { "admin" }
-
-          it "sets the namespace on the transaction" do
-            silence(:allowed => ["set_error", "The namespace argument for"]) do
-              Appsignal.set_error(error, nil, namespace)
-            end
-
-            expect(transaction).to have_error("ExampleException", "I am an exception")
-            expect(transaction).to have_namespace(namespace)
-            expect(transaction).to_not include_tags
-          end
-
-          it "prints a deprecation warning andsets the namespace on the transaction" do
-            logs = capture_logs do
-              capture_std_streams(std_stream, err_stream) do
-                Appsignal.set_error(error, nil, namespace)
-              end
-            end
-
-            message = "The namespace argument for `Appsignal.set_error` is deprecated. " \
-              "Please use the block method to set the namespace instead.\n\n" \
-              "  Appsignal.set_error(error) do |transaction|\n" \
-              "    transaction.set_namespace(#{namespace.inspect})\n" \
-              "  end\n\n" \
-              "Appsignal.set_error called on location: #{__FILE__}:"
-            expect(stderr).to include("appsignal WARNING: #{message}")
-            expect(logs).to include(message)
-          end
-        end
-
         context "when given a block" do
           it "yields the transaction and allows additional metadata to be set" do
             Appsignal.set_error(StandardError.new("my_error")) do |t|
@@ -1818,7 +1431,7 @@ describe Appsignal do
           logs = capture_logs { Appsignal.report_error(error) }
           expect(logs).to contains_log(
             :error,
-            "Appsignal.report_error: Cannot set error. " \
+            "Appsignal.report_error: Cannot add error. " \
               "The given value is not an exception: #{error.inspect}"
           )
         end
@@ -1852,6 +1465,21 @@ describe Appsignal do
             expect(transaction).to include_tags("tag1" => "value1")
             expect(transaction).to be_completed
           end
+
+          it "yields and allows additional metadata to be set with the global helpers" do
+            Appsignal.report_error(error) do
+              Appsignal.set_action("my_action")
+              Appsignal.set_namespace("my_namespace")
+              Appsignal.set_tags(:tag1 => "value1")
+            end
+
+            transaction = last_transaction
+            expect(transaction).to have_namespace("my_namespace")
+            expect(transaction).to have_action("my_action")
+            expect(transaction).to have_error("ExampleException", "error message")
+            expect(transaction).to include_tags("tag1" => "value1")
+            expect(transaction).to be_completed
+          end
         end
       end
 
@@ -1859,7 +1487,7 @@ describe Appsignal do
         let(:transaction) { http_request_transaction }
         before { set_current_transaction(transaction) }
 
-        it "adds the error to the active transaction" do
+        it "sets the error in the active transaction" do
           Appsignal.report_error(error)
 
           expect(last_transaction).to eq(transaction)
@@ -1868,6 +1496,41 @@ describe Appsignal do
           expect(transaction).to have_error("ExampleException", "error message")
         end
 
+        context "when the active transaction already has an error" do
+          let(:previous_error) { ExampleException.new("previous error message") }
+
+          before { transaction.set_error(previous_error) }
+
+          it "does not overwrite the existing set error" do
+            Appsignal.report_error(error)
+
+            transaction._sample
+            expect(transaction).to have_error("ExampleException", "previous error message")
+          end
+
+          it "adds the error to the errors" do
+            Appsignal.report_error(error)
+
+            expect(transaction.error_blocks).to eq({ error => [], previous_error => [] })
+          end
+
+          context "when given a block" do
+            it "only applies the block to the transaction for that error" do
+              Appsignal.report_error(error) do |t|
+                t.set_action("my_action")
+              end
+
+              transaction.complete
+              expect(transaction).to have_error("ExampleException", "previous error message")
+              expect(transaction).not_to have_action("my_action")
+
+              expect(last_transaction).to_not be(transaction)
+              expect(last_transaction).to have_error("ExampleException", "error message")
+              expect(last_transaction).to have_action("my_action")
+            end
+          end
+        end
+
         it "does not complete the transaction" do
           Appsignal.report_error(error)
 
@@ -1875,19 +1538,67 @@ describe Appsignal do
         end
 
         context "when given a block" do
-          it "yields the transaction and allows additional metadata to be set" do
+          before do
             Appsignal.report_error(error) do |t|
               t.set_action("my_action")
               t.set_namespace("my_namespace")
               t.set_tags(:tag1 => "value1")
             end
+          end
+
+          it "applies the block to the error transaction when completed" do
+            expect(transaction).not_to have_namespace("my_namespace")
+            expect(transaction).not_to have_action("my_action")
+            expect(transaction).not_to include_tags("tag1" => "value1")
+            expect(transaction).to have_error
+            expect(transaction).not_to be_completed
+
+            transaction.complete
+            expect(transaction).to have_namespace("my_namespace")
+            expect(transaction).to have_action("my_action")
+            expect(transaction).to include_tags("tag1" => "value1")
+            expect(transaction).to have_error
+            expect(transaction).to be_completed
+          end
+
+          it "does not apply the block to other error transactions" do
+            Appsignal.report_error(StandardError.new("another error"))
+
+            transaction.complete
+            expect(created_transactions.count).to eq(2)
 
-            transaction._sample
             expect(transaction).to have_namespace("my_namespace")
             expect(transaction).to have_action("my_action")
-            expect(transaction).to have_error("ExampleException", "error message")
             expect(transaction).to include_tags("tag1" => "value1")
+            expect(transaction).to have_error("ExampleException", "error message")
+            expect(transaction).to be_completed
+
+            expect(last_transaction).not_to be(transaction)
+            expect(last_transaction).not_to have_namespace("my_namespace")
+            expect(last_transaction).not_to have_action("my_action")
+            expect(last_transaction).not_to include_tags("tag1" => "value1")
+            expect(last_transaction).to have_error("StandardError", "another error")
+            expect(last_transaction).to be_completed
+          end
+
+          it "does not create a new transaction" do
+            expect(created_transactions).to eq([transaction])
+          end
+
+          it "yields and allows additional metadata to be set with the global helpers" do
+            Appsignal.report_error(error) do
+              Appsignal.set_action("my_action")
+              Appsignal.set_namespace("my_namespace")
+              Appsignal.set_tags(:tag1 => "value1")
+            end
+
             expect(transaction).to_not be_completed
+
+            transaction.complete
+            expect(transaction).to have_namespace("my_namespace")
+            expect(transaction).to have_action("my_action")
+            expect(transaction).to have_error("ExampleException", "error message")
+            expect(transaction).to include_tags("tag1" => "value1")
           end
         end
       end
@@ -1997,30 +1708,6 @@ describe Appsignal do
           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
@@ -2033,24 +1720,6 @@ describe Appsignal do
     end
   end
 
-  describe ".start_logger" do
-    let(:stderr_stream) { std_stream }
-    let(:stderr) { stderr_stream.read }
-    let(:log_stream) { std_stream }
-    let(:log) { log_contents(log_stream) }
-
-    it "prints and logs a deprecation warning" do
-      use_logger_with(log_stream) do
-        capture_std_streams(std_stream, stderr_stream) do
-          Appsignal.start_logger
-        end
-      end
-      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
-
   describe "._start_logger" do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
@@ -2069,11 +1738,10 @@ describe Appsignal do
     after { FileUtils.rm_rf(log_path) }
 
     def initialize_config
-      Appsignal._config = project_fixture_config(
-        "production",
-        :log_path => log_path,
-        :log_level => log_level
-      )
+      Appsignal.configure(:production, :root_path => project_fixture_path) do |config|
+        config.log_path = log_path
+        config.log_level = log_level
+      end
       Appsignal.internal_logger.error("Log in memory line 1")
       Appsignal.internal_logger.debug("Log in memory line 2")
       expect(Appsignal.in_memory_logger.messages).to_not be_empty