appsignal 4.0.5 → 4.0.7

data/spec/lib/appsignal_spec.rb

@@ -1,1919 +0,0 @@
-describe Appsignal do
-  include EnvironmentMetadataHelper
-  around { |example| keep_transactions { example.run } }
-
-  let(:transaction) { http_request_transaction }
-
-  describe ".configure" do
-    context "when active" do
-      it "doesn't update the config" do
-        start_agent
-        Appsignal::Testing.store[:config_called] = false
-        expect do
-          Appsignal.configure do |_config|
-            Appsignal::Testing.store[:config_called] = true
-          end
-        end.to_not(change { [Appsignal.config, Appsignal.active?] })
-        expect(Appsignal::Testing.store[:config_called]).to be(false)
-      end
-
-      it "logs a warning" do
-        start_agent
-        logs =
-          capture_logs do
-            Appsignal.configure do |_config|
-              # Do something
-            end
-          end
-        expect(logs).to contains_log(
-          :warn,
-          "AppSignal is already started. Ignoring `Appsignal.configure` call."
-        )
-      end
-    end
-
-    context "with config but not started" do
-      it "reuses the already loaded config if no env arg is given" do
-        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")
-          expect(config.ignore_actions).to eq(["My action"])
-
-          config.active = true
-          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")
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-        expect(Appsignal.config[:ignore_actions]).to eq(["My action"])
-      end
-
-      it "reuses the already loaded config if the env is the same" do
-        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"])
-          config.active = true
-          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)
-        expect(Appsignal.config[:name]).to eq("My app")
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-      end
-
-      it "loads a new config if the env is not the same" do
-        Appsignal.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
-          config.active = true
-          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)
-        expect(Appsignal.config[:name]).to eq("My app")
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-      end
-
-      it "loads a new config if the path is not the same" do
-        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
-          config.active = true
-          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)
-        expect(Appsignal.config[:name]).to eq("My app")
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-      end
-
-      it "calls configure if not started yet" do
-        Appsignal.configure(:my_env) do |config|
-          config.active = false
-          config.name = "Some name"
-        end
-        Appsignal.start
-        expect(Appsignal.started?).to be_falsy
-
-        Appsignal.configure(:my_env) do |config|
-          expect(config.ignore_actions).to be_empty
-          config.active = true
-          config.name = "My app"
-          config.push_api_key = "key"
-        end
-        Appsignal.start
-
-        expect(Appsignal.config.valid?).to be(true)
-        expect(Appsignal.config.env).to eq("my_env")
-        expect(Appsignal.config[:active]).to be(true)
-        expect(Appsignal.config[:name]).to eq("My app")
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-      end
-    end
-
-    context "when not active" do
-      it "starts with the configured config" do
-        Appsignal.configure(:test) do |config|
-          config.push_api_key = "key"
-        end
-        Appsignal.start
-
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-      end
-
-      it "uses the given env" do
-        ENV["APPSIGNAL_APP_ENV"] = "env_env"
-        Appsignal.configure(:env_arg)
-        Appsignal.start
-
-        expect(Appsignal.config.env).to eq("env_arg")
-      end
-
-      it "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
-        expect(Appsignal.config.file_config).to_not be_empty
-      end
-
-      it "loads the config without a block being given" 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")
-        # Ensure it loads from the config file in the current working directory
-        expect(Appsignal.config.file_config).to_not be_empty
-      end
-
-      it "allows customization of config in the block" 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")
-        expect(Appsignal.config[:push_api_key]).to eq("key")
-      end
-
-      it "loads the default config" do
-        Appsignal.configure do |config|
-          Appsignal::Config::DEFAULT_CONFIG.each do |option, value|
-            expect(config.send(option)).to eq(value)
-          end
-        end
-      end
-
-      it "loads the config from the YAML file" do
-        Dir.chdir project_fixture_path do
-          Appsignal.configure(:test) do |config|
-            expect(config.name).to eq("TestApp")
-          end
-        end
-      end
-
-      it "recognizes valid config" do
-        Appsignal.configure(:my_env) do |config|
-          config.push_api_key = "key"
-        end
-        Appsignal.start
-
-        expect(Appsignal.config.valid?).to be(true)
-      end
-
-      it "recognizes invalid config" do
-        Appsignal.configure(:my_env) do |config|
-          config.push_api_key = ""
-        end
-        Appsignal.start
-
-        expect(Appsignal.config.valid?).to be(false)
-      end
-
-      it "sets the environment when given as an argument" do
-        Appsignal.configure(:my_env)
-
-        expect(Appsignal.config.env).to eq("my_env")
-      end
-
-      it "reads the environment from the environment" do
-        ENV["APPSIGNAL_APP_ENV"] = "env_env"
-        Appsignal.configure do |config|
-          expect(config.env).to eq("env_env")
-        end
-
-        expect(Appsignal.config.env).to eq("env_env")
-      end
-
-      it "reads the environment from a loader default" do
-        clear_integration_env_vars!
-        define_loader(:loader_env) do
-          def on_load
-            register_config_defaults(
-              :env => "loader_env"
-            )
-          end
-        end
-        load_loader(:loader_env)
-
-        Appsignal.configure do |config|
-          expect(config.env).to eq("loader_env")
-        end
-
-        expect(Appsignal.config.env).to eq("loader_env")
-      end
-
-      it "reads the root_path from a loader default" do
-        clear_integration_env_vars!
-        define_loader(:loader_path) do
-          def on_load
-            register_config_defaults(
-              :root_path => "/loader_path"
-            )
-          end
-        end
-        load_loader(:loader_path)
-
-        Appsignal.configure do |config|
-          expect(config.app_path).to eq("/loader_path")
-        end
-
-        expect(Appsignal.config.root_path).to eq("/loader_path")
-      end
-
-      it "considers the given env leading above APPSIGNAL_APP_ENV" do
-        ENV["APPSIGNAL_APP_ENV"] = "env_env"
-
-        Appsignal.configure(:dsl_env) do |config|
-          expect(config.env).to eq("dsl_env")
-        end
-
-        expect(Appsignal.config.env).to eq("dsl_env")
-      end
-
-      it "allows modification of previously unset config options" do
-        expect do
-          Appsignal.configure do |config|
-            config.ignore_actions << "My action"
-            config.request_headers << "My allowed header"
-          end
-        end.to_not(change { Appsignal::Config::DEFAULT_CONFIG })
-
-        expect(Appsignal.config[:ignore_actions]).to eq(["My action"])
-        expect(Appsignal.config[:request_headers])
-          .to eq(Appsignal::Config::DEFAULT_CONFIG[:request_headers] + ["My allowed header"])
-      end
-    end
-  end
-
-  describe ".start" do
-    context "with no config set beforehand" do
-      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)
-        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)
-        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
-
-      it "reads the environment from the loader defaults" do
-        clear_integration_env_vars!
-        define_loader(:loader_env) do
-          def on_load
-            register_config_defaults(:env => "loader_env")
-          end
-        end
-        load_loader(:loader_env)
-
-        Appsignal.start
-
-        expect(Appsignal.config.env).to eq("loader_env")
-      end
-
-      it "reads the root_path from the loader defaults" do
-        define_loader(:loader_path) do
-          def on_load
-            register_config_defaults(:root_path => "/loader_path")
-          end
-        end
-        load_loader(:loader_path)
-
-        Appsignal.start
-
-        expect(Appsignal.config.root_path).to eq("/loader_path")
-      end
-
-      it "chooses APPSIGNAL_APP_ENV over the loader defaults as the default env" do
-        clear_integration_env_vars!
-        ENV["APPSIGNAL_APP_ENV"] = "env_env"
-        define_loader(:loader_env) do
-          def on_load
-            register_config_defaults(:env => "loader_env")
-          end
-        end
-        load_loader(:loader_env)
-
-        Appsignal.start
-
-        expect(Appsignal.config.env).to eq("env_env")
-      end
-    end
-
-    context "when config is loaded" do
-      before { Appsignal.configure(:production, :root_path => project_fixture_path) }
-
-      it "should initialize logging" do
-        Appsignal.start
-        expect(Appsignal.internal_logger.level).to eq Logger::INFO
-      end
-
-      it "should start native" do
-        expect(Appsignal::Extension).to receive(:start)
-        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
-          capture_environment_metadata_report_calls
-        end
-
-        unless DependencyHelper.running_jruby?
-          it "installs the allocation event hook" do
-            expect(Appsignal::Extension).to receive(:install_allocation_event_hook)
-              .and_call_original
-            Appsignal.start
-            expect_environment_metadata("ruby_allocation_tracking_enabled", "true")
-          end
-        end
-      end
-
-      context "when allocation tracking has been disabled" do
-        before do
-          Appsignal.config.config_hash[:enable_allocation_tracking] = false
-          capture_environment_metadata_report_calls
-        end
-
-        it "should not install the allocation event hook" do
-          expect(Appsignal::Extension).not_to receive(:install_allocation_event_hook)
-          Appsignal.start
-          expect_not_environment_metadata("ruby_allocation_tracking_enabled")
-        end
-      end
-
-      context "when minutely metrics has been enabled" do
-        before do
-          Appsignal.config.config_hash[:enable_minutely_probes] = true
-        end
-
-        it "should start minutely" do
-          expect(Appsignal::Probes).to receive(:start)
-          Appsignal.start
-        end
-      end
-
-      context "when minutely metrics has been disabled" do
-        before do
-          Appsignal.config.config_hash[:enable_minutely_probes] = false
-        end
-
-        it "should not start minutely" do
-          expect(Appsignal::Probes).to_not receive(:start)
-          Appsignal.start
-        end
-      end
-
-      describe "loaders" do
-        it "starts loaded loaders" do
-          Appsignal::Testing.store[:loader_loaded] = 0
-          Appsignal::Testing.store[:loader_started] = 0
-          define_loader(:start_loader) do
-            def on_load
-              Appsignal::Testing.store[:loader_loaded] += 1
-            end
-
-            def on_start
-              Appsignal::Testing.store[:loader_started] += 1
-            end
-          end
-          Appsignal::Loaders.load(:start_loader)
-          Appsignal::Loaders.start
-
-          expect(Appsignal::Testing.store[:loader_loaded]).to eq(1)
-          expect(Appsignal::Testing.store[:loader_started]).to eq(1)
-        end
-      end
-
-      describe "environment metadata" do
-        before { capture_environment_metadata_report_calls }
-
-        it "collects and reports environment metadata" do
-          Appsignal.start
-          expect_environment_metadata("ruby_version", "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}")
-          expect_environment_metadata("ruby_engine", RUBY_ENGINE)
-          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
-            expect_environment_metadata("ruby_engine_version", RUBY_ENGINE_VERSION)
-          end
-        end
-      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.configure(:test, :root_path => project_fixture_path) }
-
-      it "should change the log level" do
-        Appsignal.start
-        expect(Appsignal.internal_logger.level).to eq Logger::DEBUG
-      end
-    end
-  end
-
-  describe ".load" do
-    before do
-      TestLoader = define_loader(:appsignal_loader)
-    end
-    after do
-      Object.send(:remove_const, :TestLoader)
-    end
-
-    it "loads a loader" do
-      expect(Appsignal::Loaders.instances).to be_empty
-      Appsignal.load(:appsignal_loader)
-      expect(Appsignal::Loaders.instances)
-        .to include(:appsignal_loader => instance_of(TestLoader))
-    end
-  end
-
-  describe ".forked" do
-    context "when not active" do
-      it "does nothing" do
-        expect(Appsignal::Extension).to_not receive(:start)
-
-        Appsignal.forked
-      end
-    end
-
-    context "when active" do
-      before do
-        Appsignal.configure(:production, :root_path => project_fixture_path)
-        Appsignal.start
-      end
-
-      it "starts the logger and extension" do
-        expect(Appsignal).to receive(:_start_logger)
-        expect(Appsignal::Extension).to receive(:start)
-
-        Appsignal.forked
-      end
-    end
-  end
-
-  describe ".stop" do
-    it "calls stop on the extension" do
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
-      expect(Appsignal::Extension).to receive(:stop)
-      Appsignal.stop
-      expect(Appsignal.active?).to be_falsy
-    end
-
-    it "stops the minutely probes" do
-      Appsignal::Probes.start
-      expect(Appsignal::Probes.started?).to be_truthy
-      Appsignal.stop
-      expect(Appsignal::Probes.started?).to be_falsy
-    end
-
-    context "with context specified" do
-      it "should log the context" do
-        expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal (something)")
-        expect(Appsignal::Extension).to receive(:stop)
-        Appsignal.stop("something")
-        expect(Appsignal.active?).to be_falsy
-      end
-    end
-
-    it "calls stop on the check-in scheduler" do
-      expect(Appsignal::CheckIn.scheduler).to receive(:stop)
-      Appsignal.stop
-    end
-  end
-
-  describe ".started?" do
-    subject { Appsignal.started? }
-
-    context "when started with active config" do
-      before { start_agent }
-
-      it { is_expected.to be_truthy }
-    end
-
-    context "when started with inactive config" do
-      before { Appsignal.configure(:nonsense, :root_path => project_fixture_path) }
-
-      it { is_expected.to be_falsy }
-    end
-  end
-
-  describe ".active?" do
-    subject { Appsignal.active? }
-
-    context "without config" do
-      it { is_expected.to be_falsy }
-    end
-
-    context "with inactive config" do
-      before do
-        Appsignal.configure(:nonsense, :root_path => project_fixture_path)
-        Appsignal.start
-      end
-
-      it { is_expected.to be_falsy }
-    end
-
-    context "with active config" do
-      before do
-        Appsignal.configure(:production, :root_path => project_fixture_path)
-        Appsignal.start
-      end
-
-      it { is_expected.to be_truthy }
-    end
-  end
-
-  describe ".add_exception" do
-    it "should alias this method" do
-      expect(Appsignal).to respond_to(:add_exception)
-    end
-  end
-
-  describe ".get_server_state" do
-    it "should call server state on the extension" do
-      expect(Appsignal::Extension).to receive(:get_server_state).with("key")
-
-      Appsignal.get_server_state("key")
-    end
-
-    it "should get nil by default" do
-      expect(Appsignal.get_server_state("key")).to be_nil
-    end
-  end
-
-  context "not active" do
-    before do
-      Appsignal.configure(:not_active, :root_path => project_fixture_path)
-      Appsignal.start
-    end
-
-    describe ".send_error" 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(error)
-        end.to_not(change { created_transactions.count })
-      end
-    end
-
-    describe ".set_error" 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(error)
-        end.to_not(change { created_transactions.count })
-      end
-    end
-
-    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.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 "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
-    before { start_agent }
-    around { |example| keep_transactions { example.run } }
-
-    describe ".monitor" do
-      it "creates a transaction" do
-        expect do
-          Appsignal.monitor(:action => "MyAction")
-        end.to(change { created_transactions.count }.by(1))
-
-        transaction = last_transaction
-        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        expect(transaction).to have_action("MyAction")
-        expect(transaction).to_not have_error
-        expect(transaction).to_not include_events
-        expect(transaction).to_not have_queue_start
-        expect(transaction).to be_completed
-      end
-
-      it "returns the block's return value" do
-        expect(Appsignal.monitor(:action => nil) { :return_value }).to eq(:return_value)
-      end
-
-      it "sets a custom namespace via the namespace argument" do
-        Appsignal.monitor(:namespace => "custom", :action => nil)
-
-        expect(last_transaction).to have_namespace("custom")
-      end
-
-      it "doesn't overwrite custom namespace set in the block" do
-        Appsignal.monitor(:namespace => "custom", :action => nil) do
-          Appsignal.set_namespace("more custom")
-        end
-
-        expect(last_transaction).to have_namespace("more custom")
-      end
-
-      it "sets the action via the action argument using a string" do
-        Appsignal.monitor(:action => "custom")
-
-        expect(last_transaction).to have_action("custom")
-      end
-
-      it "sets the action via the action argument using a symbol" do
-        Appsignal.monitor(:action => :custom)
-
-        expect(last_transaction).to have_action("custom")
-      end
-
-      it "doesn't overwrite custom action set in the block" do
-        Appsignal.monitor(:action => "custom") do
-          Appsignal.set_action("more custom")
-        end
-
-        expect(last_transaction).to have_action("more custom")
-      end
-
-      it "doesn't set the action when value is nil" do
-        Appsignal.monitor(:action => nil)
-
-        expect(last_transaction).to_not have_action
-      end
-
-      it "doesn't set the action when value is :set_later" do
-        Appsignal.monitor(:action => :set_later)
-
-        expect(last_transaction).to_not have_action
-      end
-
-      it "reports exceptions that occur in the block" do
-        expect do
-          Appsignal.monitor :action => nil do
-            raise ExampleException, "error message"
-          end
-        end.to raise_error(ExampleException, "error message")
-
-        expect(last_transaction).to have_error("ExampleException", "error message")
-      end
-
-      context "with already active transction" do
-        let(:err_stream) { std_stream }
-        let(:stderr) { err_stream.read }
-        let(:transaction) { http_request_transaction }
-        before do
-          set_current_transaction(transaction)
-          transaction.set_action("My action")
-        end
-
-        it "doesn't create a new transaction" do
-          logs = nil
-          expect do
-            logs =
-              capture_logs do
-                capture_std_streams(std_stream, err_stream) do
-                  Appsignal.monitor(:action => nil)
-                end
-              end
-          end.to_not(change { created_transactions.count })
-
-          warning = "A transaction is active around this 'Appsignal.monitor' call."
-          expect(logs).to contains_log(:warn, warning)
-          expect(stderr).to include("appsignal WARNING: #{warning}")
-        end
-
-        it "does not overwrite the parent transaction's namespace" do
-          silence { Appsignal.monitor(:namespace => "custom", :action => nil) }
-
-          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        end
-
-        it "does not overwrite the parent transaction's action" do
-          silence { Appsignal.monitor(:action => "custom") }
-
-          expect(transaction).to have_action("My action")
-        end
-
-        it "doesn't complete the parent transaction" do
-          silence { Appsignal.monitor(:action => nil) }
-
-          expect(transaction).to_not be_completed
-        end
-      end
-    end
-
-    describe ".monitor_and_stop" do
-      it "calls Appsignal.stop after the block" do
-        allow(Appsignal).to receive(:stop)
-        Appsignal.monitor_and_stop(:namespace => "custom", :action => "My Action")
-
-        transaction = last_transaction
-        expect(transaction).to have_namespace("custom")
-        expect(transaction).to have_action("My Action")
-        expect(transaction).to be_completed
-
-        expect(Appsignal).to have_received(:stop).with("monitor_and_stop")
-      end
-
-      it "passes the block to Appsignal.monitor" do
-        expect do |blk|
-          Appsignal.monitor_and_stop(:action => "My action", &blk)
-        end.to yield_control
-      end
-    end
-
-    describe ".tag_request" do
-      before { start_agent }
-
-      context "with 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._sample
-          expect(transaction).to include_tags("a" => "b")
-        end
-      end
-
-      context "without transaction" do
-        let(:transaction) { nil }
-
-        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 "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_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 "adds parameters to the transaction" do
-          Appsignal.add_params("param1" => "value1")
-
-          transaction._sample
-          expect(transaction).to include_params("param1" => "value1")
-        end
-
-        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(
-            "param1" => "value1",
-            "param2" => "value2"
-          )
-        end
-
-        it "adds parameters with a block to the transaction" do
-          Appsignal.add_params { { "param1" => "value1" } }
-
-          transaction._sample
-          expect(transaction).to include_params("param1" => "value1")
-        end
-      end
-
-      context "without transaction" do
-        it "does not add tags to any transaction" do
-          Appsignal.add_params("a" => "b")
-
-          expect_any_instance_of(Appsignal::Transaction).to_not receive(:add_params)
-        end
-      end
-    end
-
-    describe ".set_empty_params!" do
-      before { start_agent }
-
-      context "with transaction" do
-        let(:transaction) { http_request_transaction }
-        before { set_current_transaction(transaction) }
-
-        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 "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(
-            "data1" => "value1",
-            "data2" => "value2"
-          )
-        end
-
-        it "adds session data with a block to the transaction" do
-          Appsignal.set_session_data { { "data" => "value1" } }
-
-          transaction._sample
-          expect(transaction).to include_session_data("data" => "value1")
-        end
-      end
-
-      context "without transaction" do
-        it "does not add session data to any transaction" do
-          Appsignal.set_session_data("a" => "b")
-
-          expect_any_instance_of(Appsignal::Transaction).to_not receive(:add_session_data)
-        end
-      end
-    end
-
-    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 "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 "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-path",
-            "REQUEST_METHOD" => "GET"
-          )
-        end
-
-        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")
-        end
-      end
-
-      context "without transaction" do
-        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(:add_headers)
-        end
-      end
-    end
-
-    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 "adds custom data to the current transaction" do
-          Appsignal.add_custom_data(
-            :user => { :id => 123 },
-            :organization => { :slug => "appsignal" }
-          )
-
-          transaction._sample
-          expect(transaction).to include_custom_data(
-            "user" => { "id" => 123 },
-            "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 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(:add_custom_data)
-        end
-      end
-    end
-
-    describe ".add_breadcrumb" do
-      before { start_agent }
-
-      context "with transaction" do
-        let(:transaction) { http_request_transaction }
-        before { set_current_transaction(transaction) }
-
-        it "adds the breadcrumb to the transaction" do
-          Appsignal.add_breadcrumb(
-            "Network",
-            "http",
-            "User made network request",
-            { :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 "does not add a breadcrumb to any transaction" do
-          expect(Appsignal.add_breadcrumb("Network", "http")).to be_falsy
-        end
-      end
-    end
-
-    describe "custom metrics" do
-      let(:tags) { { :foo => "bar" } }
-
-      describe ".set_gauge" do
-        it "should call set_gauge on the extension with a string key and float" do
-          expect(Appsignal::Extension).to receive(:set_gauge)
-            .with("key", 0.1, Appsignal::Extension.data_map_new)
-          Appsignal.set_gauge("key", 0.1)
-        end
-
-        it "should call set_gauge with tags" do
-          expect(Appsignal::Extension).to receive(:set_gauge)
-            .with("key", 0.1, Appsignal::Utils::Data.generate(tags))
-          Appsignal.set_gauge("key", 0.1, tags)
-        end
-
-        it "should call set_gauge on the extension with a symbol key and int" do
-          expect(Appsignal::Extension).to receive(:set_gauge)
-            .with("key", 1.0, Appsignal::Extension.data_map_new)
-          Appsignal.set_gauge(:key, 1)
-        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.internal_logger).to receive(:warn)
-            .with("The gauge value '10' for metric 'key' is too big")
-
-          Appsignal.set_gauge("key", 10)
-        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)
-            .with("key", 1, Appsignal::Extension.data_map_new)
-          Appsignal.increment_counter("key")
-        end
-
-        it "should call increment_counter with tags" do
-          expect(Appsignal::Extension).to receive(:increment_counter)
-            .with("key", 1, Appsignal::Utils::Data.generate(tags))
-          Appsignal.increment_counter("key", 1, tags)
-        end
-
-        it "should call increment_counter on the extension with a symbol key" do
-          expect(Appsignal::Extension).to receive(:increment_counter)
-            .with("key", 1, Appsignal::Extension.data_map_new)
-          Appsignal.increment_counter(:key)
-        end
-
-        it "should call increment_counter on the extension with a count" do
-          expect(Appsignal::Extension).to receive(:increment_counter)
-            .with("key", 5, Appsignal::Extension.data_map_new)
-          Appsignal.increment_counter("key", 5)
-        end
-
-        it "should not raise an exception when out of range" do
-          expect(Appsignal::Extension).to receive(:increment_counter)
-            .with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
-          expect(Appsignal.internal_logger).to receive(:warn)
-            .with("The counter value '10' for metric 'key' is too big")
-
-          Appsignal.increment_counter("key", 10)
-        end
-      end
-
-      describe ".add_distribution_value" do
-        it "should call add_distribution_value on the extension with a string key and float" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value)
-            .with("key", 0.1, Appsignal::Extension.data_map_new)
-          Appsignal.add_distribution_value("key", 0.1)
-        end
-
-        it "should call add_distribution_value with tags" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value)
-            .with("key", 0.1, Appsignal::Utils::Data.generate(tags))
-          Appsignal.add_distribution_value("key", 0.1, tags)
-        end
-
-        it "should call add_distribution_value on the extension with a symbol key and int" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value)
-            .with("key", 1.0, Appsignal::Extension.data_map_new)
-          Appsignal.add_distribution_value(:key, 1)
-        end
-
-        it "should not raise an exception when out of range" do
-          expect(Appsignal::Extension).to receive(:add_distribution_value)
-            .with("key", 10, Appsignal::Extension.data_map_new).and_raise(RangeError)
-          expect(Appsignal.internal_logger).to receive(:warn)
-            .with("The distribution value '10' for metric 'key' is too big")
-
-          Appsignal.add_distribution_value("key", 10)
-        end
-      end
-    end
-
-    describe ".internal_logger" do
-      subject { Appsignal.internal_logger }
-
-      it { is_expected.to be_a Logger }
-    end
-
-    describe ".log_formatter" do
-      subject { Appsignal.log_formatter.call("Debug", Time.parse("2015-07-08"), nil, "log line") }
-
-      it "formats a log" do
-        expect(subject).to eq "[2015-07-08T00:00:00 (process) ##{Process.pid}][Debug] log line\n"
-      end
-
-      context "with prefix" do
-        subject do
-          Appsignal.log_formatter("prefix").call("Debug", Time.parse("2015-07-08"), nil, "log line")
-        end
-
-        it "adds a prefix" do
-          expect(subject)
-            .to eq "[2015-07-08T00:00:00 (process) ##{Process.pid}][Debug] prefix: log line\n"
-        end
-      end
-    end
-
-    describe ".config" do
-      subject { Appsignal.config }
-
-      it { is_expected.to be_a Appsignal::Config }
-      it "should return configuration" do
-        expect(subject[:endpoint]).to eq "https://push.appsignal.com"
-      end
-    end
-
-    describe ".send_error" do
-      let(:error) { ExampleException.new("error message") }
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      around do |example|
-        keep_transactions { example.run }
-      end
-
-      it "sends the error to AppSignal" do
-        expect { Appsignal.send_error(error) }.to(change { created_transactions.count }.by(1))
-
-        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) { "string value" }
-
-        it "logs an error message" do
-          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.send_error(error) }.to_not(change { created_transactions.count })
-        end
-      end
-
-      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 have_namespace("my_namespace")
-          expect(last_transaction).to have_action("my_action")
-          expect(last_transaction).to have_error("StandardError", "my_error")
-        end
-
-        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("my_namespace")
-          expect(last_transaction).to have_action("my_action")
-          expect(last_transaction).to have_error("StandardError", "my_error")
-        end
-
-        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)
-
-          Appsignal.send_error(StandardError.new("my_error")) do
-            Appsignal.set_action("my_action")
-            Appsignal.set_namespace("my_namespace")
-          end
-
-          # Restores the active_transaction as the current transaction
-          expect(current_transaction).to eq(active_transaction)
-
-          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
-
-          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
-
-    describe ".set_error" do
-      let(:err_stream) { std_stream }
-      let(:stderr) { err_stream.read }
-      let(:error) { ExampleException.new("I am an exception") }
-      let(:transaction) { http_request_transaction }
-      around { |example| keep_transactions { example.run } }
-
-      context "when there is an active transaction" do
-        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
-            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}"
-            )
-          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|
-              t.set_action("my_action")
-              t.set_namespace("my_namespace")
-            end
-
-            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
-          Appsignal.set_error(error)
-
-          expect(transaction).to_not have_error
-        end
-      end
-    end
-
-    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 add 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
-
-          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
-
-      context "when there is an active transaction" do
-        let(:transaction) { http_request_transaction }
-        before { set_current_transaction(transaction) }
-
-        it "sets the error in 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
-
-        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)
-
-          expect(last_transaction).to_not be_completed
-        end
-
-        context "when given a block" 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)
-
-            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("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
-    end
-
-    describe ".set_action" do
-      around { |example| keep_transactions { example.run } }
-
-      context "with current transaction" do
-        before { set_current_transaction(transaction) }
-
-        it "sets the namespace on the current transaction" do
-          Appsignal.set_action("custom")
-
-          expect(transaction).to have_action("custom")
-        end
-
-        it "does not set the action if the action is nil" do
-          Appsignal.set_action(nil)
-
-          expect(transaction).to_not have_action
-        end
-      end
-
-      context "without current transaction" do
-        it "does not set ther action" do
-          Appsignal.set_action("custom")
-
-          expect(transaction).to_not have_action
-        end
-      end
-    end
-
-    describe ".set_namespace" do
-      around { |example| keep_transactions { example.run } }
-
-      context "with current transaction" do
-        before { set_current_transaction(transaction) }
-
-        it "should set the namespace to the current transaction" do
-          Appsignal.set_namespace("custom")
-
-          expect(transaction).to have_namespace("custom")
-        end
-
-        it "does not update the namespace if the namespace is nil" do
-          Appsignal.set_namespace(nil)
-
-          expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
-        end
-      end
-
-      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")
-
-          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 { set_current_transaction(transaction) }
-      end
-    end
-
-    describe ".instrument_sql" do
-      around { |example| keep_transactions { example.run } }
-      before { set_current_transaction(transaction) }
-
-      it "creates an SQL event on the transaction" do
-        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 ".ignore_instrumentation_events" do
-      around { |example| keep_transactions { example.run } }
-      let(:transaction) { http_request_transaction }
-
-      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.ignore_instrumentation_events do
-            Appsignal.instrument("dont.register.this.event") { :do_nothing }
-          end
-
-          expect(transaction).to include_event("name" => "register.this.event")
-          expect(transaction).to_not include_event("name" => "dont.register.this.event")
-        end
-      end
-
-      context "without current transaction" do
-        let(:transaction) { nil }
-
-        it "does not crash" do
-          Appsignal.ignore_instrumentation_events { :do_nothing }
-        end
-      end
-    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_logger)
-        Appsignal.remove_instance_variable(:@in_memory_logger)
-      end
-    end
-    after { FileUtils.rm_rf(log_path) }
-
-    def initialize_config
-      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
-    end
-
-    context "when the log path is writable" do
-      context "when the log file is writable" do
-        let(:log_file_contents) { File.read(log_file) }
-
-        before do
-          capture_stdout(out_stream) do
-            initialize_config
-            Appsignal._start_logger
-            Appsignal.internal_logger.error("Log to file")
-          end
-          expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
-        end
-
-        it "logs to file" do
-          expect(File.exist?(log_file)).to be_truthy
-          expect(log_file_contents).to include "[ERROR] Log to file"
-          expect(output).to be_empty
-        end
-
-        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.instance_variable_get(:@in_memory_logger)).to be_nil
-        end
-      end
-
-      context "when the log file is not writable" do
-        before do
-          FileUtils.touch log_file
-          FileUtils.chmod 0o444, log_file
-
-          capture_stdout(out_stream) do
-            initialize_config
-            Appsignal._start_logger
-            Appsignal.internal_logger.error("Log to not writable log file")
-            expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
-          end
-        end
-
-        it "logs to stdout" do
-          expect(File.writable?(log_file)).to be_falsy
-          expect(output).to include "[ERROR] appsignal: Log to not writable log file"
-        end
-
-        it "amends in memory log to stdout" do
-          expect(output).to include "[ERROR] appsignal: Log in memory"
-        end
-
-        it "clears the in memory log after writing to the new logger" do
-          expect(Appsignal.instance_variable_get(:@in_memory_logger)).to be_nil
-        end
-
-        it "outputs a warning" do
-          expect(output).to include \
-            "[WARN] appsignal: Unable to start internal logger with log path '#{log_file}'.",
-            "[WARN] appsignal: Permission denied"
-        end
-      end
-    end
-
-    context "when the log path and fallback path are not writable" do
-      before do
-        FileUtils.chmod 0o444, log_path
-        FileUtils.chmod 0o444, Appsignal::Config.system_tmp_dir
-
-        capture_stdout(out_stream) do
-          initialize_config
-          Appsignal._start_logger
-          Appsignal.internal_logger.error("Log to not writable log path")
-        end
-        expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
-      end
-      after do
-        FileUtils.chmod 0o755, Appsignal::Config.system_tmp_dir
-      end
-
-      it "logs to stdout" do
-        expect(File.writable?(log_path)).to be_falsy
-        expect(output).to include "[ERROR] appsignal: Log to not writable log path"
-      end
-
-      it "amends in memory log to stdout" do
-        expect(output).to include "[ERROR] appsignal: Log in memory"
-      end
-
-      it "outputs a warning" do
-        expect(output).to include \
-          "appsignal: Unable to log to '#{log_path}' " \
-            "or the '#{Appsignal::Config.system_tmp_dir}' fallback."
-      end
-    end
-
-    context "when on Heroku" do
-      before do
-        capture_stdout(out_stream) do
-          initialize_config
-          Appsignal._start_logger
-          Appsignal.internal_logger.error("Log to stdout")
-        end
-        expect(Appsignal.internal_logger).to be_a(Appsignal::Utils::IntegrationLogger)
-      end
-      around { |example| recognize_as_heroku { example.run } }
-
-      it "logs to stdout" do
-        expect(output).to include "[ERROR] appsignal: Log to stdout"
-      end
-
-      it "amends in memory log to stdout" do
-        expect(output).to include "[ERROR] appsignal: Log in memory"
-      end
-
-      it "clears the in memory log after writing to the new logger" do
-        expect(Appsignal.instance_variable_get(:@in_memory_logger)).to be_nil
-      end
-    end
-
-    describe "#logger#level" do
-      subject { Appsignal.internal_logger.level }
-
-      context "when there is no config" do
-        before do
-          capture_stdout(out_stream) do
-            Appsignal._start_logger
-          end
-        end
-
-        it "sets the log level to info" do
-          expect(subject).to eq Logger::INFO
-        end
-      end
-
-      context "when there is a config" do
-        context "when log level is configured to debug" do
-          before do
-            capture_stdout(out_stream) do
-              initialize_config
-              Appsignal.config[:log_level] = "debug"
-              Appsignal._start_logger
-            end
-          end
-
-          it "sets the log level to debug" do
-            expect(subject).to eq Logger::DEBUG
-          end
-        end
-      end
-    end
-  end
-end