appsignal 2.9.18 → 2.10.0

data/spec/lib/appsignal/cli/helpers_spec.rb

@@ -24,7 +24,7 @@ describe Appsignal::CLI::Helpers do
   describe ".colorize" do
     subject { cli.send(:colorize, "text", :green) }
 
-    context "on windows" do
+    context "when on windows" do
       before { allow(Gem).to receive(:win_platform?).and_return(true) }
 
       it "outputs plain string" do
@@ -32,11 +32,19 @@ describe Appsignal::CLI::Helpers do
       end
     end
 
-    context "not on windows" do
+    context "when coloring is set to false" do
+      before { cli.send(:coloring=, false) }
+
+      it "outputs plain string" do
+        expect(subject).to eq "text"
+      end
+    end
+
+    context "when not on windows" do
       before { allow(Gem).to receive(:win_platform?).and_return(false) }
 
       it "wraps text in color tags" do
-        expect(subject).to eq "\e[32mtext\e[0m"
+        expect(subject).to have_colorized_text(:green, "text")
       end
     end
   end

data/spec/lib/appsignal/cli/install_spec.rb

@@ -9,6 +9,7 @@ describe Appsignal::CLI::Install do
   let(:config) { Appsignal::Config.new(tmp_dir, "") }
   let(:config_file_path) { File.join(tmp_dir, "config", "appsignal.yml") }
   let(:config_file) { File.read(config_file_path) }
+  let(:options) { {} }
   before do
     stub_api_validation_request
     # Stub calls to speed up tests
@@ -91,7 +92,7 @@ describe Appsignal::CLI::Install do
     Dir.chdir tmp_dir do
       prepare_cli_input
       capture_stdout(out_stream) do
-        run_cli(["install", push_api_key])
+        run_cli(["install", push_api_key], options)
       end
     end
   end
@@ -667,6 +668,34 @@ describe Appsignal::CLI::Install do
       it_behaves_like "push_api_key validation"
       it_behaves_like "demo data"
 
+      context "without color options" do
+        let(:options) { {} }
+
+        it "prints the instructions in color" do
+          run
+          expect(output).to have_colorized_text(:green, "## Starting AppSignal Installer      ##")
+        end
+      end
+
+      context "with --color option" do
+        let(:options) { { "color" => nil } }
+
+        it "prints the instructions in color" do
+          run
+          expect(output).to have_colorized_text(:green, "## Starting AppSignal Installer      ##")
+        end
+      end
+
+      context "with --no-color option" do
+        let(:options) { { "no-color" => nil } }
+
+        it "prints the instructions without special colors" do
+          run
+          expect(output).to include("Starting AppSignal Installer")
+          expect(output).to_not have_color_markers
+        end
+      end
+
       it "prints a message about unknown framework" do
         run
 

data/spec/lib/appsignal/config_spec.rb

@@ -47,15 +47,43 @@ describe Appsignal::Config do
       subject { config[:active] }
 
       context "with APPSIGNAL_PUSH_API_KEY env variable" do
-        before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
+        context "when not empty" do
+          before { ENV["APPSIGNAL_PUSH_API_KEY"] = "abc" }
 
-        it "becomes active" do
-          expect(subject).to be_truthy
+          it "becomes active" do
+            expect(subject).to be_truthy
+          end
+
+          it "sets the push_api_key as loaded through the env_config" do
+            expect(config.env_config).to eq(:push_api_key => "abc")
+            expect(config.system_config).to eq(:active => true)
+          end
+        end
+
+        context "when empty string" do
+          before { ENV["APPSIGNAL_PUSH_API_KEY"] = "" }
+
+          it "does not becomes active" do
+            expect(subject).to be_falsy
+          end
+
+          it "sets the push_api_key as loaded through the env_config" do
+            expect(config.env_config).to eq(:push_api_key => "")
+            expect(config.system_config).to be_empty
+          end
         end
 
-        it "sets the push_api_key as loaded through the env_config" do
-          expect(config.env_config).to eq(:push_api_key => "abc")
-          expect(config.system_config).to eq(:active => true)
+        context "when blank string" do
+          before { ENV["APPSIGNAL_PUSH_API_KEY"] = " " }
+
+          it "does not becomes active" do
+            expect(subject).to be_falsy
+          end
+
+          it "sets the push_api_key as loaded through the env_config" do
+            expect(config.env_config).to eq(:push_api_key => " ")
+            expect(config.system_config).to be_empty
+          end
         end
       end
 
@@ -215,6 +243,30 @@ describe Appsignal::Config do
       end
     end
 
+    context "with the config file causing an error" do
+      let(:config_path) do
+        File.expand_path(
+          File.join(File.dirname(__FILE__), "../../support/fixtures/projects/broken")
+        )
+      end
+      let(:config) { Appsignal::Config.new(config_path, "foo") }
+
+      it "logs & prints an error, skipping the file source" do
+        stdout = std_stream
+        stderr = std_stream
+        log = capture_logs { capture_std_streams(stdout, stderr) { config } }
+        message = "An error occured while loading the AppSignal config file. " \
+          "Skipping file config.\n" \
+          "File: #{File.join(config_path, "config", "appsignal.yml").inspect}\n" \
+          "NotExistingConstant: uninitialized constant NotExistingConstant\n"
+        expect(log).to contains_log :error, message
+        expect(log).to include("/appsignal/config.rb:") # Backtrace
+        expect(stdout.read).to_not include("appsignal:")
+        expect(stderr.read).to include "appsignal: #{message}"
+        expect(config.file_config).to eql({})
+      end
+    end
+
     it "sets the file_config" do
       # config found in spec/support/project_fixture/config/appsignal.yml
       expect(config.file_config).to match(
@@ -265,7 +317,7 @@ describe Appsignal::Config do
         expect_any_instance_of(Logger).to receive(:error).once
           .with("Not loading from config file: config for 'nonsense' not found")
         expect_any_instance_of(Logger).to receive(:error).once
-          .with("Push api key not set after loading config")
+          .with("Push API key not set after loading config")
         config
       end
     end
@@ -724,6 +776,22 @@ describe Appsignal::Config do
         end
       end
 
+      context "with empty push_api_key" do
+        let(:push_api_key) { "" }
+
+        it "sets valid to false" do
+          is_expected.to eq(false)
+        end
+      end
+
+      context "with blank push_api_key" do
+        let(:push_api_key) { " " }
+
+        it "sets valid to false" do
+          is_expected.to eq(false)
+        end
+      end
+
       context "with push_api_key present" do
         let(:push_api_key) { "abc" }
 

data/spec/lib/appsignal/hooks/action_cable_spec.rb

@@ -54,16 +54,12 @@ describe Appsignal::Hooks::ActionCableHook do
             .with(transaction_id, Appsignal::Transaction::ACTION_CABLE, kind_of(ActionDispatch::Request))
             .and_return(transaction)
           allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-          # Make sure sample data is added
-          expect(transaction.ext).to receive(:finish).and_return(true)
-          # Stub complete call, stops it from being cleared in the extension
-          # And allows us to call `#to_h` on it after it's been completed.
-          expect(transaction.ext).to receive(:complete)
 
           # Stub transmit call for subscribe/unsubscribe tests
           allow(connection).to receive(:websocket)
             .and_return(instance_double("ActionCable::Connection::WebSocket", :transmit => nil))
         end
+        around { |example| keep_transactions { example.run } }
 
         describe "#perform_action" do
           it "creates a transaction for an action" do

data/spec/lib/appsignal/hooks/rake_spec.rb

@@ -4,69 +4,71 @@ describe Appsignal::Hooks::RakeHook do
   let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
   let(:arguments) { Rake::TaskArguments.new(["foo"], ["bar"]) }
   let(:generic_request) { Appsignal::Transaction::GenericRequest.new({}) }
-  before(:context) do
-    Appsignal.config = project_fixture_config
-    expect(Appsignal.active?).to be_truthy
-    Appsignal::Hooks.load_hooks
-  end
+  before(:context) { start_agent }
 
   describe "#execute" do
     context "without error" do
+      before { expect(Appsignal).to_not receive(:stop) }
+
+      def perform
+        task.execute(arguments)
+      end
+
       it "creates no transaction" do
-        expect(Appsignal::Transaction).to_not receive(:create)
+        expect(Appsignal::Transaction).to_not receive(:new)
+        expect { perform }.to_not(change { created_transactions })
       end
 
       it "calls the original task" do
-        expect(task).to receive(:execute_without_appsignal).with("foo")
+        expect(task).to receive(:execute_without_appsignal).with(arguments)
+        perform
       end
-
-      after { task.execute("foo") }
     end
 
     context "with error" do
       let(:error) { ExampleException }
-      let(:transaction) { background_job_transaction }
       before do
-        task.enhance { raise error }
-
-        expect(Appsignal::Transaction).to receive(:create).with(
-          kind_of(String),
-          Appsignal::Transaction::BACKGROUND_JOB,
-          kind_of(Appsignal::Transaction::GenericRequest)
-        ).and_return(transaction)
+        task.enhance { raise error, "my error message" }
+        # We don't call `and_call_original` here as we don't want AppSignal to
+        # stop and start for every spec.
+        expect(Appsignal).to receive(:stop).with("rake")
       end
 
-      it "sets the action" do
-        expect(transaction).to receive(:set_action).with("task:name")
-      end
-
-      it "sets the error" do
-        expect(transaction).to receive(:set_error).with(error)
+      def perform
+        keep_transactions do
+          expect { task.execute(arguments) }.to raise_error(error)
+        end
       end
 
-      it "completes the transaction and stops" do
-        expect(transaction).to receive(:complete).ordered
-        expect(Appsignal).to receive(:stop).with("rake").ordered
-      end
+      it "creates a background job transaction" do
+        perform
 
-      it "adds the task arguments to the request" do
-        expect(Appsignal::Transaction::GenericRequest).to receive(:new)
-          .with(:params => { :foo => "bar" })
-          .and_return(generic_request)
+        expect(last_transaction).to be_completed
+        expect(last_transaction.to_h).to include(
+          "id" => kind_of(String),
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "action" => "task:name",
+          "error" => {
+            "name" => "ExampleException",
+            "message" => "my error message",
+            "backtrace" => kind_of(String)
+          },
+          "sample_data" => hash_including(
+            "params" => { "foo" => "bar" }
+          )
+        )
       end
 
       context "when first argument is not a `Rake::TaskArguments`" do
         let(:arguments) { nil }
 
-        it "adds the first argument regardless" do
-          expect(Appsignal::Transaction::GenericRequest).to receive(:new)
-            .with(:params => nil)
-            .and_return(generic_request)
-        end
-      end
+        it "does not add the params to the transaction" do
+          perform
 
-      after do
-        expect { task.execute(arguments) }.to raise_error ExampleException
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_excluding("params")
+          )
+        end
       end
     end
   end

data/spec/lib/appsignal/hooks/sidekiq_spec.rb

@@ -38,28 +38,15 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     }
   end
   let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
-  let(:test_store) { {} }
   let(:log) { StringIO.new }
   before do
     start_agent
     Appsignal.logger = test_logger(log)
-
-    # Stub calls to extension, because that would remove the transaction
-    # from the extension.
-    allow_any_instance_of(Appsignal::Extension::Transaction).to receive(:finish).and_return(true)
-    allow_any_instance_of(Appsignal::Extension::Transaction).to receive(:complete)
-
-    # Stub removal of current transaction from current thread so we can fetch
-    # it later.
-    expect(Appsignal::Transaction).to receive(:clear_current_transaction!) do
-      transaction = Thread.current[:appsignal_transaction]
-      test_store[:transaction] = transaction if transaction
-    end
   end
+  around { |example| keep_transactions { example.run } }
   after :with_yaml_parse_error => false do
     expect(log_contents(log)).to_not contains_log(:warn, "Unable to load YAML")
   end
-  after { clear_current_transaction! }
 
   shared_examples "sidekiq metadata" do
     describe "internal Sidekiq job values" do
@@ -513,7 +500,7 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   end
 
   def transaction
-    test_store[:transaction]
+    last_transaction
   end
 
   def expect_transaction_to_have_sidekiq_event(transaction_hash)

data/spec/lib/appsignal/integrations/object_spec.rb

@@ -16,8 +16,8 @@ describe Object do
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
-          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
           Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
         end
         after { Appsignal.config = nil }
 
@@ -137,9 +137,9 @@ describe Object do
       context "when active" do
         let(:transaction) { http_request_transaction }
         before do
+          Appsignal.config = project_fixture_config
           expect(Appsignal::Transaction).to receive(:current).at_least(:once)
             .and_return(transaction)
-          Appsignal.config = project_fixture_config
         end
         after { Appsignal.config = nil }
 

data/spec/lib/appsignal/integrations/que_spec.rb

@@ -37,47 +37,30 @@ if DependencyHelper.que_present?
         end
       end
       let(:instance) { job.new(job_attrs) }
-      let(:transaction) do
-        Appsignal::Transaction.new(
-          SecureRandom.uuid,
-          Appsignal::Transaction::BACKGROUND_JOB,
-          Appsignal::Transaction::GenericRequest.new(env)
-        )
-      end
 
       before do
         allow(Que).to receive(:execute)
 
         start_agent
         expect(Appsignal.active?).to be_truthy
-        transaction
-
-        expect(Appsignal::Transaction).to receive(:create)
-          .with(
-            kind_of(String),
-            Appsignal::Transaction::BACKGROUND_JOB,
-            kind_of(Appsignal::Transaction::GenericRequest)
-          ).and_return(transaction)
-        allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-        expect(transaction.ext).to receive(:finish).and_return(true)
-        expect(transaction.ext).to receive(:complete)
       end
-
-      subject { transaction.to_h }
+      around { |example| keep_transactions { example.run } }
 
       context "success" do
         it "creates a transaction for a job" do
           expect do
             instance._run
-          end.to_not raise_exception
+          end.to change { created_transactions.length }.by(1)
 
-          expect(subject).to include(
+          expect(last_transaction).to be_completed
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash).to include(
             "action" => "MyQueJob#run",
             "id" => instance_of(String),
             "namespace" => Appsignal::Transaction::BACKGROUND_JOB
           )
-          expect(subject["error"]).to be_nil
-          expect(subject["events"].first).to include(
+          expect(transaction_hash["error"]).to be_nil
+          expect(transaction_hash["events"].first).to include(
             "allocation_count" => kind_of(Integer),
             "body" => "",
             "body_format" => Appsignal::EventFormatter::DEFAULT,
@@ -91,7 +74,7 @@ if DependencyHelper.que_present?
             "name" => "perform_job.que",
             "title" => ""
           )
-          expect(subject["sample_data"]).to include(
+          expect(transaction_hash["sample_data"]).to include(
             "params" => %w[1 birds],
             "metadata" => {
               "attempts" => 0,
@@ -107,24 +90,28 @@ if DependencyHelper.que_present?
       context "with exception" do
         let(:error) { ExampleException.new("oh no!") }
 
-        it "should report exceptions and re-raise them" do
+        it "reports exceptions and re-raise them" do
           allow(instance).to receive(:run).and_raise(error)
 
           expect do
-            instance._run
-          end.to raise_error(ExampleException)
-
-          expect(subject).to include(
+            expect do
+              instance._run
+            end.to raise_error(ExampleException)
+          end.to change { created_transactions.length }.by(1)
+
+          expect(last_transaction).to be_completed
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash).to include(
             "action" => "MyQueJob#run",
             "id" => instance_of(String),
             "namespace" => Appsignal::Transaction::BACKGROUND_JOB
           )
-          expect(subject["error"]).to include(
+          expect(transaction_hash["error"]).to include(
             "backtrace" => kind_of(String),
             "name" => error.class.name,
             "message" => error.message
           )
-          expect(subject["sample_data"]).to include(
+          expect(transaction_hash["sample_data"]).to include(
             "params" => %w[1 birds],
             "metadata" => {
               "attempts" => 0,
@@ -140,24 +127,24 @@ if DependencyHelper.que_present?
       context "with error" do
         let(:error) { ExampleStandardError.new("oh no!") }
 
-        it "should report errors and not re-raise them" do
+        it "reports errors and not re-raise them" do
           allow(instance).to receive(:run).and_raise(error)
 
-          expect do
-            instance._run
-          end.to_not raise_error
+          expect { instance._run }.to change { created_transactions.length }.by(1)
 
-          expect(subject).to include(
+          expect(last_transaction).to be_completed
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash).to include(
             "action" => "MyQueJob#run",
             "id" => instance_of(String),
             "namespace" => Appsignal::Transaction::BACKGROUND_JOB
           )
-          expect(subject["error"]).to include(
+          expect(transaction_hash["error"]).to include(
             "backtrace" => kind_of(String),
             "name" => error.class.name,
             "message" => error.message
           )
-          expect(subject["sample_data"]).to include(
+          expect(transaction_hash["sample_data"]).to include(
             "params" => %w[1 birds],
             "metadata" => {
               "attempts" => 0,