appsignal 3.9.2-java → 3.10.0-java

data/spec/lib/appsignal_spec.rb

@@ -1,5 +1,6 @@
 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
@@ -21,21 +22,30 @@ describe Appsignal do
 
   describe ".start" do
     context "with no config set beforehand" do
-      it "should do nothing when config is not set and there is no valid config in the env" do
-        expect(Appsignal.internal_logger).to receive(:error)
-          .with("Push API key not set after loading config").once
-        expect(Appsignal.internal_logger).to receive(:error)
-          .with("Not starting, no valid config for this environment").once
+      let(:stdout_stream) { std_stream }
+      let(:stdout) { stdout_stream.read }
+      let(:stderr_stream) { std_stream }
+      let(:stderr) { stderr_stream.read }
+      before { ENV["APPSIGNAL_LOG"] = "stdout" }
+
+      it "does nothing when config is not set and there is no valid config in the env" do
         expect(Appsignal::Extension).to_not receive(:start)
-        Appsignal.start
+        capture_std_streams(stdout_stream, stderr_stream) { Appsignal.start }
+
+        expect(stdout).to contains_log(
+          :error,
+          "appsignal: Not starting, no valid config for this environment"
+        )
       end
 
       it "should create a config from the env" do
         ENV["APPSIGNAL_PUSH_API_KEY"] = "something"
         expect(Appsignal::Extension).to receive(:start)
-        expect(Appsignal.internal_logger).not_to receive(:error)
-        silence { Appsignal.start }
+        capture_std_streams(stdout_stream, stderr_stream) { Appsignal.start }
+
         expect(Appsignal.config[:push_api_key]).to eq("something")
+        expect(stderr).to_not include("[ERROR]")
+        expect(stdout).to_not include("[ERROR]")
       end
     end
 
@@ -129,7 +139,7 @@ describe Appsignal do
 
   describe ".forked" do
     context "when not active" do
-      it "should should do nothing" do
+      it "does nothing" do
         expect(Appsignal::Extension).to_not receive(:start)
 
         Appsignal.forked
@@ -141,8 +151,8 @@ describe Appsignal do
         Appsignal.config = project_fixture_config
       end
 
-      it "should resubscribe and start the extension" do
-        expect(Appsignal).to receive(:start_logger)
+      it "starts the logger and extension" do
+        expect(Appsignal).to receive(:_start_logger)
         expect(Appsignal::Extension).to receive(:start)
 
         Appsignal.forked
@@ -222,28 +232,26 @@ describe Appsignal do
   end
 
   context "not active" do
-    describe ".monitor_transaction" do
-      let(:log_stream) { StringIO.new }
-      let(:log) { log_contents(log_stream) }
-      before do
-        Appsignal.config = project_fixture_config("not_active")
-        Appsignal.start
-        Appsignal.start_logger
-        Appsignal.internal_logger = test_logger(log_stream)
-      end
-      after { Appsignal.internal_logger = nil }
+    before { Appsignal.config = project_fixture_config("not_active") }
 
-      it "should do nothing but still yield the block" do
-        expect(Appsignal::Transaction).to_not receive(:create)
-        expect(Appsignal).to_not receive(:instrument)
-        object = double
-        expect(object).to receive(:some_method).and_return(1)
+    describe ".monitor_transaction" do
+      it "does not create a transaction" do
+        object = double(:some_method => 1)
 
         expect do
-          expect(Appsignal.monitor_transaction("perform_job.nothing") do
+          Appsignal.monitor_transaction("perform_job.nothing") do
             object.some_method
-          end).to eq 1
-        end.to_not raise_error
+          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
@@ -254,8 +262,11 @@ describe Appsignal do
         end
 
         it "logs an error" do
-          Appsignal.monitor_transaction("unknown.sidekiq") {} # rubocop:disable Lint/EmptyBlock
-          expect(log).to contains_log(
+          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)"
@@ -265,111 +276,149 @@ describe Appsignal do
     end
 
     describe ".listen_for_error" do
-      it "does not record anything" do
-        error = RuntimeError.new("specific error")
+      let(:error) { ExampleException.new("specific error") }
+
+      it "reraises the error" do
         expect do
-          Appsignal.listen_for_error do
-            raise error
-          end
+          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
     end
 
     describe ".send_error" do
-      it "should do nothing" do
+      let(:error) { ExampleException.new("specific error") }
+
+      it "does not raise an error" do
+        Appsignal.send_error(error)
+      end
+
+      it "does not create a transaction" do
         expect do
-          Appsignal.send_error(RuntimeError.new)
-        end.to_not raise_error
+          Appsignal.send_error(error)
+        end.to_not(change { created_transactions.count })
       end
     end
 
     describe ".set_error" do
-      it "should do nothing" do
+      let(:error) { ExampleException.new("specific error") }
+
+      it "does not raise an error" do
+        Appsignal.set_error(error)
+      end
+
+      it "does not create a transaction" do
         expect do
-          Appsignal.set_error(RuntimeError.new)
-        end.to_not raise_error
+          Appsignal.set_error(error)
+        end.to_not(change { created_transactions.count })
       end
     end
 
-    describe ".set_namespace" do
-      it "should do nothing" do
+    describe ".report_error" do
+      let(:error) { ExampleException.new("specific error") }
+
+      it "does not raise an error" do
+        Appsignal.report_error(error)
+      end
+
+      it "does not create a transaction" do
         expect do
-          Appsignal.set_namespace("custom")
-        end.to_not raise_error
+          Appsignal.report_error(error)
+        end.to_not(change { created_transactions.count })
+      end
+    end
+
+    describe ".set_namespace" do
+      it "does not raise an error" do
+        Appsignal.set_namespace("custom")
       end
     end
 
     describe ".tag_request" do
-      it "should do nothing" do
-        expect do
-          Appsignal.tag_request(:tag => "tag")
-        end.to_not raise_error
+      it "does not raise an error" do
+        Appsignal.tag_request(:tag => "tag")
+      end
+    end
+
+    describe ".set_custom_data" do
+      it "does not raise an error" do
+        Appsignal.set_custom_data(:data => "value")
       end
     end
   end
 
   context "with config and started" do
-    let(:log_stream) { StringIO.new }
-    let(:log) { log_contents(log_stream) }
-    before do
-      Appsignal.config = project_fixture_config
-      Appsignal.start
-      Appsignal.start_logger
-      Appsignal.internal_logger = test_logger(log_stream)
-    end
-    after { Appsignal.internal_logger = nil }
+    before { start_agent }
+    around { |example| keep_transactions { example.run } }
 
     describe ".monitor_transaction" do
       context "with a successful call" do
-        it "should instrument and complete for a background job" do
-          expect(Appsignal).to receive(:instrument)
-            .with("perform_job.something").and_yield
-          expect(Appsignal::Transaction).to receive(:complete_current!)
-          object = double
-          expect(object).to receive(:some_method).and_return(1)
-
-          expect(Appsignal.monitor_transaction(
-            "perform_job.something",
-            background_env_with_data
-          ) do
-            current = Appsignal::Transaction.current
-            expect(current.namespace).to eq Appsignal::Transaction::BACKGROUND_JOB
-            expect(current.request).to be_a(Appsignal::Transaction::GenericRequest)
-            object.some_method
-          end).to eq 1
+        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"
+                }
+              ) 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 be_completed
         end
 
-        it "should instrument and complete for a http request" do
-          expect(Appsignal).to receive(:instrument)
-            .with("process_action.something").and_yield
-          expect(Appsignal::Transaction).to receive(:complete_current!)
-          object = double
-          expect(object).to receive(:some_method)
+        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"
+                }
+              ) do
+                :return_value
+              end
+          end.to(change { created_transactions.count }.by(1))
+          expect(return_value).to eq(:return_value)
 
-          Appsignal.monitor_transaction(
-            "process_action.something",
-            http_request_env_with_data
-          ) do
-            current = Appsignal::Transaction.current
-            expect(current.namespace).to eq Appsignal::Transaction::HTTP_REQUEST
-            expect(current.request).to be_a(::Rack::Request)
-            object.some_method
-          end
+          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 be_completed
         end
       end
 
       context "with an erroring call" do
-        let(:error) { ExampleException.new }
-
-        it "should add the error to the current transaction and complete" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
-          expect(Appsignal::Transaction).to receive(:complete_current!)
+        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
 
@@ -381,8 +430,11 @@ describe Appsignal do
         end
 
         it "logs an error" do
-          Appsignal.monitor_transaction("unknown.sidekiq") {} # rubocop:disable Lint/EmptyBlock
-          expect(log).to contains_log(
+          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)"
@@ -392,8 +444,6 @@ describe Appsignal do
     end
 
     describe ".monitor_single_transaction" do
-      around { |example| keep_transactions { example.run } }
-
       context "with a successful call" do
         it "calls monitor_transaction and Appsignal.stop" do
           expect(Appsignal).to receive(:stop)
@@ -407,18 +457,8 @@ describe Appsignal do
           end
 
           transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "action" => "my_controller#my_action"
-          )
-          expect(transaction_hash["events"]).to match([
-            hash_including(
-              "name" => "perform_job.something",
-              "title" => "",
-              "body" => "",
-              "body_format" => Appsignal::EventFormatter::DEFAULT
-            )
-          ])
+          expect(transaction).to have_action("my_controller#my_action")
+          expect(transaction).to include_event("name" => "perform_job.something")
         end
       end
 
@@ -439,75 +479,131 @@ describe Appsignal do
           end.to raise_error(error)
 
           transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "action" => "my_controller#my_action"
-          )
-          expect(transaction_hash["events"]).to match([
-            hash_including(
-              "name" => "perform_job.something",
-              "title" => "",
-              "body" => "",
-              "body_format" => Appsignal::EventFormatter::DEFAULT
-            )
-          ])
+          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
-      let(:transaction) { http_request_transaction }
-      around do |example|
-        start_agent
-        with_current_transaction transaction do
-          keep_transactions { example.run }
-        end
-      end
+      before { start_agent }
 
       context "with transaction" do
-        it "calls set_tags on the current transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "sets tags on the current transaction" do
           Appsignal.tag_request("a" => "b")
-          transaction.complete # Manually trigger transaction sampling
 
-          expect(transaction.to_h).to include(
-            "sample_data" => hash_including(
-              "tags" => { "a" => "b" }
-            )
-          )
+          transaction._sample
+          expect(transaction).to include_tags("a" => "b")
         end
       end
 
       context "without transaction" do
         let(:transaction) { nil }
 
-        it "should call set_tags on transaction" do
+        it "does not set tags on the transaction" do
           expect(Appsignal.tag_request).to be_falsy
+          Appsignal.tag_request("a" => "b")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_tags)
         end
       end
 
-      it "should also listen to tag_job" do
-        expect(Appsignal).to respond_to(:tag_job)
+      it "also listens to tag_job" do
+        expect(Appsignal.method(:tag_job)).to eq(Appsignal.method(:tag_request))
+      end
+
+      it "also listens to set_tags" do
+        expect(Appsignal.method(:set_tags)).to eq(Appsignal.method(:tag_request))
       end
     end
 
-    describe ".add_breadcrumb" do
-      before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
+    describe ".set_params" do
+      before do
+        start_agent
+      end
 
       context "with transaction" do
         let(:transaction) { http_request_transaction }
-        around do |example|
-          Appsignal.config = project_fixture_config
-          set_current_transaction transaction do
-            example.run
-          end
+        before { set_current_transaction(transaction) }
+
+        it "sets parameters on the transaction" do
+          Appsignal.set_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")
+
+          transaction._sample
+          expect(transaction).to include_params("param2" => "value2")
+        end
+
+        it "sets parameters with a block on the transaction" do
+          Appsignal.set_params { { "param1" => "value1" } }
+
+          transaction._sample
+          expect(transaction).to include_params("param1" => "value1")
+        end
+      end
+
+      context "without transaction" do
+        it "does not set tags on the transaction" do
+          Appsignal.set_params("a" => "b")
+
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_params)
+        end
+      end
+    end
+
+    describe ".set_custom_data" do
+      before { start_agent }
+
+      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(
+            :user => { :id => 123 },
+            :organization => { :slug => "appsignal" }
+          )
+
+          transaction._sample
+          expect(transaction).to include_custom_data(
+            "user" => { "id" => 123 },
+            "organization" => { "slug" => "appsignal" }
+          )
         end
+      end
+
+      context "without transaction" do
+        it "does not set tags on the transaction" do
+          Appsignal.set_custom_data(
+            :user => { :id => 123 },
+            :organization => { :slug => "appsignal" }
+          )
 
-        it "should call add_breadcrumb on transaction" do
-          expect(transaction).to receive(:add_breadcrumb)
-            .with("Network", "http", "User made network request", { :response => 200 }, fixed_time)
+          expect_any_instance_of(Appsignal::Transaction).to_not receive(:set_custom_data)
         end
+      end
+    end
+
+    describe ".add_breadcrumb" do
+      around do |example|
+        start_agent
+        with_current_transaction(transaction) { example.run }
+      end
 
-        after do
+      context "with transaction" do
+        let(:transaction) { http_request_transaction }
+
+        it "adds the breadcrumb to the transaction" do
           Appsignal.add_breadcrumb(
             "Network",
             "http",
@@ -515,13 +611,22 @@ describe Appsignal do
             { :response => 200 },
             fixed_time
           )
+
+          transaction._sample
+          expect(transaction).to include_breadcrumb(
+            "http",
+            "Network",
+            "User made network request",
+            { "response" => 200 },
+            fixed_time
+          )
         end
       end
 
       context "without transaction" do
         let(:transaction) { nil }
 
-        it "should not call add_breadcrumb on transaction" do
+        it "does not add a breadcrumb to any transaction" do
           expect(Appsignal.add_breadcrumb("Network", "http")).to be_falsy
         end
       end
@@ -550,13 +655,15 @@ describe Appsignal do
         end
 
         it "should not raise an exception when out of range" do
-          expect(Appsignal::Extension).to receive(:set_gauge).with("key", 10,
-            Appsignal::Extension.data_map_new).and_raise(RangeError)
+          expect(Appsignal::Extension).to receive(:set_gauge).with(
+            "key",
+            10,
+            Appsignal::Extension.data_map_new
+          ).and_raise(RangeError)
           expect(Appsignal.internal_logger).to receive(:warn)
             .with("Gauge value 10 for key 'key' is too big")
-          expect do
-            Appsignal.set_gauge("key", 10)
-          end.to_not raise_error
+
+          Appsignal.set_gauge("key", 10)
         end
       end
 
@@ -634,9 +741,8 @@ describe Appsignal do
             .with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
           expect(Appsignal.internal_logger).to receive(:warn)
             .with("Counter value 10 for key 'key' is too big")
-          expect do
-            Appsignal.increment_counter("key", 10)
-          end.to_not raise_error
+
+          Appsignal.increment_counter("key", 10)
         end
       end
 
@@ -664,9 +770,8 @@ describe Appsignal do
             .with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
           expect(Appsignal.internal_logger).to receive(:warn)
             .with("Distribution value 10 for key 'key' is too big")
-          expect do
-            Appsignal.add_distribution_value("key", 10)
-          end.to_not raise_error
+
+          Appsignal.add_distribution_value("key", 10)
         end
       end
     end
@@ -706,46 +811,39 @@ describe Appsignal do
     end
 
     describe ".send_error" do
-      let(:transaction) do
-        Appsignal::Transaction.new(
-          SecureRandom.uuid,
-          Appsignal::Transaction::HTTP_REQUEST,
-          Appsignal::Transaction::GenericRequest.new({})
-        )
-      end
-      let(:error) { ExampleException.new }
+      let(:error) { ExampleException.new("error message") }
       let(:err_stream) { std_stream }
       let(:stderr) { err_stream.read }
-      around { |example| keep_transactions { example.run } }
+      around do |example|
+        keep_transactions { example.run }
+      end
 
       it "sends the error to AppSignal" do
-        expect(Appsignal::Transaction).to receive(:new).with(
-          kind_of(String),
-          Appsignal::Transaction::HTTP_REQUEST,
-          kind_of(Appsignal::Transaction::GenericRequest)
-        ).and_return(transaction)
-        expect(transaction).to receive(:set_error).with(error)
-        expect(transaction).to_not receive(:set_tags)
-        expect(transaction).to receive(:complete)
+        expect { Appsignal.send_error(error) }.to(change { created_transactions.count }.by(1))
 
-        Appsignal.send_error(error)
+        transaction = last_transaction
+        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        expect(transaction).to_not have_action
+        expect(transaction).to have_error("ExampleException", "error message")
+        expect(transaction).to_not include_tags
+        expect(transaction).to be_completed
       end
 
       context "when given error is not an Exception" do
-        let(:error) { double }
+        let(:error) { "string value" }
 
         it "logs an error message" do
-          expect(Appsignal.internal_logger).to receive(:error).with(
+          logs = capture_logs { Appsignal.send_error(error) }
+          expect(logs).to contains_log(
+            :error,
             "Appsignal.send_error: Cannot send error. " \
               "The given value is not an exception: #{error.inspect}"
           )
         end
 
         it "does not send the error" do
-          expect(Appsignal::Transaction).to_not receive(:create)
+          expect { Appsignal.send_error(error) }.to_not(change { created_transactions.count })
         end
-
-        after { Appsignal.send_error(error) }
       end
 
       context "with tags" do
@@ -760,13 +858,7 @@ describe Appsignal do
             end.to change { created_transactions.count }.by(1)
           end
 
-          transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "sample_data" => hash_including(
-              "tags" => { "a" => "a", "b" => "b" }
-            )
-          )
+          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" \
@@ -791,9 +883,7 @@ describe Appsignal do
             end.to change { created_transactions.count }.by(1)
           end
 
-          transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include("namespace" => namespace)
+          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" \
@@ -808,23 +898,15 @@ describe Appsignal do
 
       context "when given a block" do
         it "yields the transaction and allows additional metadata to be set" do
-          captured_transaction = nil
           keep_transactions do
             Appsignal.send_error(StandardError.new("my_error")) do |transaction|
-              captured_transaction = transaction
               transaction.set_action("my_action")
               transaction.set_namespace("my_namespace")
             end
           end
-          expect(captured_transaction.to_h).to include(
-            "namespace" => "my_namespace",
-            "action" => "my_action",
-            "error" => {
-              "name" => "StandardError",
-              "message" => "my_error",
-              "backtrace" => kind_of(String) # TODO: should be Array
-            }
-          )
+          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
@@ -841,17 +923,10 @@ describe Appsignal do
           end.to raise_error(ExampleException, "I am an exception")
         end.to change { created_transactions.count }.by(1)
 
-        expect(last_transaction.to_h).to include(
-          "error" => {
-            "name" => "ExampleException",
-            "message" => "I am an exception",
-            "backtrace" => kind_of(String)
-          },
-          "namespace" => Appsignal::Transaction::HTTP_REQUEST, # Default namespace
-          "sample_data" => hash_including(
-            "tags" => {}
-          )
-        )
+        # 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
@@ -864,17 +939,10 @@ describe Appsignal do
             end.to raise_error(ExampleException, "I am an exception")
           end.to change { created_transactions.count }.by(1)
 
-          expect(last_transaction.to_h).to include(
-            "error" => {
-              "name" => "ExampleException",
-              "message" => "I am an exception",
-              "backtrace" => kind_of(String)
-            },
-            "namespace" => Appsignal::Transaction::HTTP_REQUEST, # Default namespace
-            "sample_data" => hash_including(
-              "tags" => { "foo" => "bar" }
-            )
-          )
+          # 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
 
@@ -888,17 +956,10 @@ describe Appsignal do
             end.to raise_error(ExampleException, "I am an exception")
           end.to change { created_transactions.count }.by(1)
 
-          expect(last_transaction.to_h).to include(
-            "error" => {
-              "name" => "ExampleException",
-              "message" => "I am an exception",
-              "backtrace" => kind_of(String)
-            },
-            "namespace" => "custom_namespace",
-            "sample_data" => hash_including(
-              "tags" => {}
-            )
-          )
+          # 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
         end
       end
     end
@@ -907,42 +968,56 @@ describe Appsignal do
       let(:err_stream) { std_stream }
       let(:stderr) { err_stream.read }
       let(:error) { ExampleException.new("I am an exception") }
-      before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
+      let(:transaction) { http_request_transaction }
       around { |example| keep_transactions { example.run } }
 
       context "when there is an active transaction" do
-        it "adds the error to the active transaction" do
-          expect(transaction).to receive(:set_error).with(error)
-          expect(transaction).to_not receive(:set_tags)
-          expect(transaction).to_not receive(:set_namespace)
+        before { set_current_transaction(transaction) }
 
+        it "adds the error to the active transaction" do
           Appsignal.set_error(error)
+
+          transaction._sample
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+          expect(transaction).to have_error("ExampleException", "I am an exception")
+          expect(transaction).to_not include_tags
         end
 
         context "when the error is not an Exception" do
           let(:error) { Object.new }
 
+          it "does not set an error" do
+            silence { Appsignal.set_error(error) }
+
+            transaction._sample
+            expect(transaction).to_not have_error
+            expect(transaction).to_not include_tags
+          end
+
           it "logs an error" do
-            expect(Appsignal.internal_logger).to receive(:error).with(
+            logs = capture_logs { Appsignal.set_error(error) }
+            expect(logs).to contains_log(
+              :error,
               "Appsignal.set_error: Cannot set error. " \
                 "The given value is not an exception: #{error.inspect}"
             )
-            expect(transaction).to_not receive(:set_error)
-            expect(transaction).to_not receive(:set_tags)
-            expect(transaction).to_not receive(:set_namespace)
-
-            Appsignal.set_error(error)
           end
         end
 
         context "with tags" do
           let(:tags) { { "foo" => "bar" } }
 
-          it "prints a deprecation warning and tags the transaction" do
-            expect(transaction).to receive(:set_error).with(error)
-            expect(transaction).to receive(:set_tags).with(tags)
-            expect(transaction).to_not receive(:set_namespace)
+          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)
@@ -963,11 +1038,17 @@ describe Appsignal do
         context "with namespace" do
           let(:namespace) { "admin" }
 
-          it "prints a deprecation warning andsets the namespace on the transaction" do
-            expect(transaction).to receive(:set_error).with(error)
-            expect(transaction).to_not receive(:set_tags)
-            expect(transaction).to receive(:set_namespace).with(namespace)
+          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)
@@ -987,135 +1068,232 @@ describe Appsignal do
 
         context "when given a block" do
           it "yields the transaction and allows additional metadata to be set" do
-            captured_transaction = nil
-            keep_transactions do
-              Appsignal.set_error(StandardError.new("my_error")) do |transaction|
-                captured_transaction = transaction
-                transaction.set_action("my_action")
-                transaction.set_namespace("my_namespace")
-              end
+            Appsignal.set_error(StandardError.new("my_error")) do |t|
+              t.set_action("my_action")
+              t.set_namespace("my_namespace")
             end
 
-            expect(transaction).to eql(captured_transaction)
-            expect(captured_transaction.to_h).to include(
-              "namespace" => "my_namespace",
-              "action" => "my_action",
-              "error" => {
-                "name" => "StandardError",
-                "message" => "my_error",
-                "backtrace" => kind_of(String)
-              }
-            )
+            expect(transaction).to have_namespace("my_namespace")
+            expect(transaction).to have_action("my_action")
+            expect(transaction).to have_error("StandardError", "my_error")
           end
         end
       end
 
       context "when there is no active transaction" do
         it "does nothing" do
-          allow(Appsignal::Transaction).to receive(:current).and_return(nil)
+          Appsignal.set_error(error)
 
-          expect(transaction).to_not receive(:set_error)
+          expect(transaction).to_not have_error
+        end
+      end
+    end
 
-          Appsignal.set_error(error)
+    describe ".report_error" do
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
+      let(:error) { ExampleException.new("error message") }
+      before { start_agent }
+      around { |example| keep_transactions { example.run } }
+
+      context "when the error is not an Exception" do
+        let(:error) { Object.new }
+
+        it "does not set an error" do
+          silence { Appsignal.report_error(error) }
+
+          expect(last_transaction).to_not have_error
+        end
+
+        it "logs an error" do
+          logs = capture_logs { Appsignal.report_error(error) }
+          expect(logs).to contains_log(
+            :error,
+            "Appsignal.report_error: Cannot set error. " \
+              "The given value is not an exception: #{error.inspect}"
+          )
+        end
+      end
+
+      context "when there is no active transaction" do
+        it "creates a new transaction" do
+          expect do
+            Appsignal.report_error(error)
+          end.to(change { created_transactions.count }.by(1))
+        end
+
+        it "completes the transaction" do
+          Appsignal.report_error(error)
+
+          expect(last_transaction).to be_completed
+        end
+
+        context "when given a block" do
+          it "yields the transaction and allows additional metadata to be set" do
+            Appsignal.report_error(error) do |t|
+              t.set_action("my_action")
+              t.set_namespace("my_namespace")
+              t.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
+
+      context "when there is an active transaction" do
+        let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
+
+        it "adds the error to the active transaction" do
+          Appsignal.report_error(error)
+
+          expect(last_transaction).to eq(transaction)
+          transaction._sample
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+          expect(transaction).to have_error("ExampleException", "error message")
+        end
+
+        it "does not complete the transaction" do
+          Appsignal.report_error(error)
+
+          expect(last_transaction).to_not be_completed
+        end
+
+        context "when given a block" do
+          it "yields the transaction and allows additional metadata to be set" do
+            Appsignal.report_error(error) do |t|
+              t.set_action("my_action")
+              t.set_namespace("my_namespace")
+              t.set_tags(:tag1 => "value1")
+            end
+
+            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_not be_completed
+          end
         end
       end
     end
 
     describe ".set_action" do
-      before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
+      around { |example| keep_transactions { example.run } }
 
-      it "should set the namespace to the current transaction" do
-        expect(transaction).to receive(:set_action).with("custom")
+      context "with current transaction" do
+        before { set_current_transaction(transaction) }
 
-        Appsignal.set_action("custom")
-      end
+        it "sets the namespace on the current transaction" do
+          Appsignal.set_action("custom")
 
-      it "should do nothing if there is no current transaction" do
-        allow(Appsignal::Transaction).to receive(:current).and_return(nil)
+          expect(transaction).to have_action("custom")
+        end
 
-        expect(transaction).to_not receive(:set_action)
+        it "does not set the action if the action is nil" do
+          Appsignal.set_action(nil)
 
-        Appsignal.set_action("custom")
+          expect(transaction).to_not have_action
+        end
       end
 
-      it "should do nothing if the error is nil" do
-        expect(transaction).to_not receive(:set_action)
+      context "without current transaction" do
+        it "does not set ther action" do
+          Appsignal.set_action("custom")
 
-        Appsignal.set_action(nil)
+          expect(transaction).to_not have_action
+        end
       end
     end
 
     describe ".set_namespace" do
-      before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
+      around { |example| keep_transactions { example.run } }
 
-      it "should set the namespace to the current transaction" do
-        expect(transaction).to receive(:set_namespace).with("custom")
+      context "with current transaction" do
+        before { set_current_transaction(transaction) }
 
-        Appsignal.set_namespace("custom")
-      end
+        it "should set the namespace to the current transaction" do
+          Appsignal.set_namespace("custom")
 
-      it "should do nothing if there is no current transaction" do
-        allow(Appsignal::Transaction).to receive(:current).and_return(nil)
+          expect(transaction).to have_namespace("custom")
+        end
 
-        expect(transaction).to_not receive(:set_namespace)
+        it "does not update the namespace if the namespace is nil" do
+          Appsignal.set_namespace(nil)
 
-        Appsignal.set_namespace("custom")
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        end
       end
 
-      it "should do nothing if the error is nil" do
-        expect(transaction).to_not receive(:set_namespace)
+      context "without current transaction" do
+        it "does not update the namespace" do
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+
+          Appsignal.set_namespace("custom")
 
-        Appsignal.set_namespace(nil)
+          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        end
       end
     end
 
     describe ".instrument" do
       it_behaves_like "instrument helper" do
         let(:instrumenter) { Appsignal }
-        before do
-          expect(Appsignal::Transaction).to receive(:current).at_least(:once)
-            .and_return(transaction)
-        end
+        before { set_current_transaction(transaction) }
       end
     end
 
     describe ".instrument_sql" do
-      before do
-        expect(Appsignal::Transaction).to receive(:current).at_least(:once)
-          .and_return(transaction)
-      end
+      around { |example| keep_transactions { example.run } }
+      before { set_current_transaction(transaction) }
 
       it "creates an SQL event on the transaction" do
-        expect(transaction).to receive(:start_event)
-        expect(transaction).to receive(:finish_event)
-          .with("name", "title", "body", Appsignal::EventFormatter::SQL_BODY_FORMAT)
+        result =
+          Appsignal.instrument_sql "name", "title", "body" do
+            "return value"
+          end
 
-        result = Appsignal.instrument_sql "name", "title", "body" do
-          "return value"
-        end
         expect(result).to eq "return value"
+        expect(transaction).to include_event(
+          "name" => "name",
+          "title" => "title",
+          "body" => "body",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT
+        )
       end
     end
 
     describe ".without_instrumentation" do
+      around { |example| keep_transactions { example.run } }
       let(:transaction) { http_request_transaction }
-      before { allow(Appsignal::Transaction).to receive(:current).and_return(transaction) }
 
-      it "does not record events on the transaction" do
-        expect(transaction).to receive(:pause!).and_call_original
-        expect(transaction).to receive(:resume!).and_call_original
-        Appsignal.instrument("register.this.event") { :do_nothing }
-        Appsignal.without_instrumentation do
-          Appsignal.instrument("dont.register.this.event") { :do_nothing }
+      context "with current transaction" do
+        before { set_current_transaction(transaction) }
+
+        it "does not record events on the transaction" do
+          expect(transaction).to receive(:pause!).and_call_original
+          expect(transaction).to receive(:resume!).and_call_original
+
+          Appsignal.instrument("register.this.event") { :do_nothing }
+          Appsignal.without_instrumentation 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
-        expect(transaction.to_h["events"].map { |e| e["name"] })
-          .to match_array("register.this.event")
       end
 
-      context "without transaction" do
+      context "without current transaction" do
         let(:transaction) { nil }
 
-        it "should not crash" do
+        it "does not crash" do
           Appsignal.without_instrumentation { :do_nothing }
         end
       end
@@ -1123,17 +1301,35 @@ describe Appsignal do
   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: Callng 'Appsignal.start_logger' is deprecated.")
+      expect(log).to contains_log(:warn, "Callng 'Appsignal.start_logger' is deprecated.")
+    end
+  end
+
+  describe "._start_logger" do
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
     let(:log_path) { File.join(tmp_dir, "log") }
     let(:log_file) { File.join(log_path, "appsignal.log") }
+    let(:log_level) { "debug" }
 
     before do
       FileUtils.mkdir_p(log_path)
       # Clear state from previous test
       Appsignal.internal_logger = nil
-      if Appsignal.instance_variable_defined?(:@in_memory_log)
-        Appsignal.remove_instance_variable(:@in_memory_log)
+      if Appsignal.instance_variable_defined?(:@in_memory_logger)
+        Appsignal.remove_instance_variable(:@in_memory_logger)
       end
     end
     after { FileUtils.rm_rf(log_path) }
@@ -1141,10 +1337,12 @@ describe Appsignal do
     def initialize_config
       Appsignal.config = project_fixture_config(
         "production",
-        :log_path => log_path
+        :log_path => log_path,
+        :log_level => log_level
       )
-      Appsignal.internal_logger.error("Log in memory")
-      expect(Appsignal.in_memory_log.string).to_not be_empty
+      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
     end
 
     context "when the log path is writable" do
@@ -1154,7 +1352,7 @@ describe Appsignal do
         before do
           capture_stdout(out_stream) do
             initialize_config
-            Appsignal.start_logger
+            Appsignal._start_logger
             Appsignal.internal_logger.error("Log to file")
           end
           expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
@@ -1166,12 +1364,26 @@ describe Appsignal do
           expect(output).to be_empty
         end
 
-        it "amends in memory log to log file" do
-          expect(log_file_contents).to include "[ERROR] appsignal: Log in memory"
+        context "with log level info" do
+          let(:log_level) { "info" }
+
+          it "amends info log level and higher memory log messages to log file" do
+            expect(log_file_contents).to include "[ERROR] appsignal: Log in memory line 1"
+            expect(log_file_contents).to_not include "[DEBUG]"
+          end
+        end
+
+        context "with log level debug" do
+          let(:log_level) { "debug" }
+
+          it "amends debug log level and higher memory log messages to log file" do
+            expect(log_file_contents).to include "[ERROR] appsignal: Log in memory line 1"
+            expect(log_file_contents).to include "[DEBUG] appsignal: Log in memory line 2"
+          end
         end
 
         it "clears the in memory log after writing to the new logger" do
-          expect(Appsignal.in_memory_log.string).to be_empty
+          expect(Appsignal.instance_variable_get(:@in_memory_logger)).to be_nil
         end
       end
 
@@ -1182,7 +1394,7 @@ describe Appsignal do
 
           capture_stdout(out_stream) do
             initialize_config
-            Appsignal.start_logger
+            Appsignal._start_logger
             Appsignal.internal_logger.error("Log to not writable log file")
             expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
           end
@@ -1198,7 +1410,7 @@ describe Appsignal do
         end
 
         it "clears the in memory log after writing to the new logger" do
-          expect(Appsignal.in_memory_log.string).to be_empty
+          expect(Appsignal.instance_variable_get(:@in_memory_logger)).to be_nil
         end
 
         it "outputs a warning" do
@@ -1216,7 +1428,7 @@ describe Appsignal do
 
         capture_stdout(out_stream) do
           initialize_config
-          Appsignal.start_logger
+          Appsignal._start_logger
           Appsignal.internal_logger.error("Log to not writable log path")
         end
         expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
@@ -1245,7 +1457,7 @@ describe Appsignal do
       before do
         capture_stdout(out_stream) do
           initialize_config
-          Appsignal.start_logger
+          Appsignal._start_logger
           Appsignal.internal_logger.error("Log to stdout")
         end
         expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
@@ -1261,7 +1473,7 @@ describe Appsignal do
       end
 
       it "clears the in memory log after writing to the new logger" do
-        expect(Appsignal.in_memory_log.string).to be_empty
+        expect(Appsignal.instance_variable_get(:@in_memory_logger)).to be_nil
       end
     end
 
@@ -1272,7 +1484,7 @@ describe Appsignal do
         before do
           Appsignal.config = nil
           capture_stdout(out_stream) do
-            Appsignal.start_logger
+            Appsignal._start_logger
           end
         end
 
@@ -1287,7 +1499,7 @@ describe Appsignal do
             capture_stdout(out_stream) do
               initialize_config
               Appsignal.config[:log_level] = "debug"
-              Appsignal.start_logger
+              Appsignal._start_logger
             end
           end