appsignal 2.9.17 → 2.10.0

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -23,9 +23,15 @@ module Appsignal
     # @see http://docs.appsignal.com/front-end/error-handling.html
     # @api private
     class JSExceptionCatcher
+      include Appsignal::Utils::DeprecationMessage
+
       def initialize(app, _options = nil)
         Appsignal.logger.debug \
           "Initializing Appsignal::Rack::JSExceptionCatcher"
+        message = "The Appsignal::Rack::JSExceptionCatcher is deprecated. " \
+          "Please use the official AppSignal JavaScript integration instead. " \
+          "https://docs.appsignal.com/front-end/"
+        deprecation_message message, Appsignal.logger
         @app = app
       end
 

data/lib/appsignal/transaction.rb

@@ -25,7 +25,7 @@ module Appsignal
           Thread.current[:appsignal_transaction] = Appsignal::Transaction.new(id, namespace, request, options)
         else
           # Otherwise, log the issue about trying to start another transaction
-          Appsignal.logger.debug "Trying to start new transaction with id " \
+          Appsignal.logger.warn "Trying to start new transaction with id " \
             "'#{id}', but a transaction with id '#{current.transaction_id}' " \
             "is already running. Using transaction '#{current.transaction_id}'."
 

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.9.17".freeze
+  VERSION = "2.10.0".freeze
 end

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

@@ -2,7 +2,7 @@ require "bundler/cli"
 require "bundler/cli/common"
 require "appsignal/cli"
 
-describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_input do
+describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_input, :color => false do
   include CLIHelpers
 
   class DiagnosticsReportEndpoint
@@ -24,7 +24,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
     let(:out_stream) { std_stream }
     let(:output) { out_stream.read }
     let(:config) { project_fixture_config }
-    let(:cli) { described_class }
+    let(:cli_class) { described_class }
     let(:options) { { :environment => config.env } }
     let(:gem_path) { Bundler::CLI::Common.select_spec("appsignal").full_gem_path.strip }
     let(:received_report) { DiagnosticsReportEndpoint.received_report }
@@ -34,11 +34,11 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
     before do
       # Clear previous reports
       DiagnosticsReportEndpoint.clear_report!
-      if cli.instance_variable_defined? :@data
+      if cli_class.instance_variable_defined? :@data
         # Because this is saved on the class rather than an instance of the
         # class we need to clear it like this in case a certain test doesn't
         # generate a report.
-        cli.remove_instance_variable :@data
+        cli_class.remove_instance_variable :@data
       end
 
       if DependencyHelper.rails_present?
@@ -54,16 +54,18 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
     before :api_stub => true do
       stub_api_request config, "auth"
     end
+    before(:color => false) { options["no-color"] = nil }
+    before(:color => true) { options["color"] = nil }
     before(:send_report => :yes_cli_input) do
       accept_prompt_to_send_diagnostics_report
       capture_diagnatics_report_request
     end
     before(:send_report => :no_cli_input) { dont_accept_prompt_to_send_diagnostics_report }
     before(:send_report => :yes_cli_option) do
-      options[:send_report] = true
+      options["send-report"] = nil
       capture_diagnatics_report_request
     end
-    before(:send_report => :no_cli_option) { options[:send_report] = false }
+    before(:send_report => :no_cli_option) { options["no-send-report"] = nil }
     after { Appsignal.config = nil }
 
     def capture_diagnatics_report_request
@@ -77,7 +79,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
     def run_within_dir(chdir)
       prepare_cli_input
       Dir.chdir chdir do
-        capture_stdout(out_stream) { cli.run(options) }
+        capture_stdout(out_stream) { run_cli("diagnose", options) }
       end
     end
 
@@ -228,6 +230,14 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
 
         it "outputs extension is not loaded" do
           expect(output).to include "Extension loaded: false"
+          expect(output).to include "Extension is not loaded. No agent report created."
+        end
+
+        context "with color", :color => true do
+          it "outputs extension is not loaded in color" do
+            expect(output).to have_colorized_text :red,
+              "  Extension is not loaded. No agent report created."
+          end
         end
 
         it "transmits extension_loaded: false in report" do
@@ -682,6 +692,12 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
       context "without environment" do
         let(:config) { project_fixture_config(nil) }
         let(:options) { {} }
+        let(:warning_message) do
+          "    Warning: No environment set, no config loaded!\n" \
+            "    Please make sure appsignal diagnose is run within your\n" \
+            "    project directory with an environment.\n" \
+            "      appsignal diagnose --environment=production"
+        end
         before do
           ENV.delete("RAILS_ENV") # From spec_helper
           ENV.delete("RACK_ENV")
@@ -689,10 +705,15 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
         end
 
         it "outputs a warning that no config is loaded" do
-          expect(output).to include \
-            "Environment: \"\"\n",
-            "    Warning: No environment set, no config loaded!",
-            "  appsignal diagnose --environment=production"
+          expect(output).to include "Environment: \"\"\n#{warning_message}"
+          expect(output).to_not have_color_markers
+        end
+
+        context "with color", :color => true do
+          it "outputs a warning that no config is loaded in color" do
+            expect(output).to include "Environment: \"\"\n"
+            expect(output).to have_colorized_text :red, warning_message
+          end
         end
 
         it "outputs config defaults" do
@@ -890,6 +911,13 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
             "Validating Push API key: valid"
         end
 
+        context "with color", :color => true do
+          it "outputs valid in color" do
+            expect(output).to include "Validation",
+              "Validating Push API key: #{colorize("valid", :green)}"
+          end
+        end
+
         it "transmits validation in report" do
           expect(received_report).to include(
             "validation" => {
@@ -910,6 +938,13 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
             "Validating Push API key: invalid"
         end
 
+        context "with color", :color => true do
+          it "outputs invalid in color" do
+            expect(output).to include "Validation",
+              "Validating Push API key: #{colorize("invalid", :red)}"
+          end
+        end
+
         it "transmits validation in report" do
           expect(received_report).to include(
             "validation" => {
@@ -931,6 +966,14 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :send_report => :yes_cli_i
             %("Could not confirm authorization: 500")
         end
 
+        context "with color", :color => true do
+          it "outputs error in color" do
+            expect(output).to include "Validation",
+              "Validating Push API key: " +
+              colorize(%(Failed with status 500\n"Could not confirm authorization: 500"), :red)
+          end
+        end
+
         it "transmits validation in report" do
           expect(received_report).to include(
             "validation" => {

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
 
@@ -134,6 +162,7 @@ describe Appsignal::Config do
         :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :dns_servers                    => [],
         :files_world_accessible         => true,
+        :transaction_debug_mode         => false,
         :revision                       => "v2.5.1",
         :request_headers                => []
       )
@@ -214,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(
@@ -264,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
@@ -473,6 +526,7 @@ describe Appsignal::Config do
       config[:filter_parameters] = %w[password confirm_password]
       config[:running_in_container] = false
       config[:dns_servers] = ["8.8.8.8", "8.8.4.4"]
+      config[:transaction_debug_mode] = true
       config[:revision] = "v2.5.1"
       config.write_to_environment
     end
@@ -500,6 +554,7 @@ describe Appsignal::Config do
       expect(ENV["_APPSIGNAL_CA_FILE_PATH"]).to                 eq File.join(resources_dir, "cacert.pem")
       expect(ENV["_APPSIGNAL_DNS_SERVERS"]).to                  eq "8.8.8.8,8.8.4.4"
       expect(ENV["_APPSIGNAL_FILES_WORLD_ACCESSIBLE"]).to       eq "true"
+      expect(ENV["_APPSIGNAL_TRANSACTION_DEBUG_MODE"]).to       eq "true"
       expect(ENV["_APP_REVISION"]).to                           eq "v2.5.1"
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIR_PATH")
       expect(ENV).to_not                                        have_key("_APPSIGNAL_WORKING_DIRECTORY_PATH")
@@ -721,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