appsignal 2.9.18.beta.1 → 2.10.6.beta.1

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

@@ -18,65 +18,66 @@ if DependencyHelper.resque_present?
           extend Appsignal::Integrations::ResquePlugin
 
           def self.perform
-            raise ExampleException
+            raise ExampleException, "my error message"
           end
         end
       end
 
       describe :around_perform_resque_plugin do
-        let(:transaction) { Appsignal::Transaction.new("1", "background", {}, {}) }
         let(:job) { ::Resque::Job.new("default", "class" => "TestJob") }
-        before do
-          allow(transaction).to receive(:complete).and_return(true)
-          allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-          expect(Appsignal).to receive(:stop)
-        end
+        before { expect(Appsignal).to receive(:stop) }
 
         context "without exception" do
           it "creates a new transaction" do
-            expect(Appsignal::Transaction).to receive(:create).and_return(transaction)
-          end
+            expect do
+              keep_transactions { job.perform }
+            end.to change { created_transactions.length }.by(1)
 
-          it "wraps it in a transaction with the correct params" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.resque",
-              :class => "TestJob",
-              :method => "perform"
+            expect(last_transaction).to be_completed
+            expect(last_transaction.to_h).to include(
+              "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+              "action" => "TestJob#perform",
+              "error" => nil,
+              "events" => [
+                hash_including(
+                  "name" => "perform_job.resque",
+                  "title" => "",
+                  "body" => "",
+                  "body_format" => Appsignal::EventFormatter::DEFAULT,
+                  "count" => 1,
+                  "duration" => kind_of(Float)
+                )
+              ]
             )
           end
-
-          it "closes the transaction" do
-            expect(transaction).to receive(:complete)
-          end
-
-          after { job.perform }
         end
 
         context "with exception" do
           let(:job) { ::Resque::Job.new("default", "class" => "BrokenTestJob") }
-          let(:transaction) do
-            Appsignal::Transaction.new(
-              SecureRandom.uuid,
-              Appsignal::Transaction::BACKGROUND_JOB,
-              Appsignal::Transaction::GenericRequest.new({})
-            )
-          end
-          before do
-            allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-            expect(Appsignal::Transaction).to receive(:create)
-              .with(
-                kind_of(String),
-                Appsignal::Transaction::BACKGROUND_JOB,
-                kind_of(Appsignal::Transaction::GenericRequest)
-              ).and_return(transaction)
+
+          def perform
+            keep_transactions do
+              expect do
+                job.perform
+              end.to raise_error(ExampleException, "my error message")
+            end
           end
 
           it "sets the exception on the transaction" do
-            expect(transaction).to receive(:set_error).with(ExampleException)
-          end
+            expect do
+              perform
+            end.to change { created_transactions.length }.by(1)
 
-          after do
-            expect { job.perform }.to raise_error(ExampleException)
+            expect(last_transaction).to be_completed
+            expect(last_transaction.to_h).to include(
+              "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+              "action" => "BrokenTestJob#perform",
+              "error" => {
+                "name" => "ExampleException",
+                "message" => "my error message",
+                "backtrace" => kind_of(String)
+              }
+            )
           end
         end
       end

data/spec/lib/appsignal/logger_spec.rb

@@ -0,0 +1,25 @@
+describe Appsignal::Logger do
+  let(:log) { std_stream }
+  let(:logger) do
+    Appsignal::Logger.new(log).tap do |l|
+      l.formatter = logger_formatter
+    end
+  end
+
+  describe "#seen_keys" do
+    it "returns a Set" do
+      expect(logger.seen_keys).to be_a(Set)
+    end
+  end
+
+  describe "#warn_once_then_debug" do
+    it "only warns once, then uses debug" do
+      message = "This is a log line"
+      3.times { logger.warn_once_then_debug(:key, message) }
+
+      logs = log_contents(log)
+      expect(logs.scan(/#{Regexp.escape(log_line(:WARN, message))}/).count).to eql(1)
+      expect(logs.scan(/#{Regexp.escape(log_line(:DEBUG, message))}/).count).to eql(2)
+    end
+  end
+end

data/spec/lib/appsignal/minutely_spec.rb

@@ -189,7 +189,7 @@ describe Appsignal::Minutely do
       expect(Appsignal::Minutely).to have_received(:initial_wait_time).once
       expect do
         # Fetch old thread
-        thread = Appsignal::Minutely.class_variable_get(:@@thread)
+        thread = Appsignal::Minutely.instance_variable_get(:@thread)
         Appsignal::Minutely.start
         thread && thread.join # Wait for old thread to exit
       end.to_not(change { alive_thread_counter.call })
@@ -203,7 +203,7 @@ describe Appsignal::Minutely do
 
     it "stops the minutely thread" do
       Appsignal::Minutely.start
-      thread = Appsignal::Minutely.class_variable_get(:@@thread)
+      thread = Appsignal::Minutely.instance_variable_get(:@thread)
       expect(%w[sleep run]).to include(thread.status)
       Appsignal::Minutely.stop
       thread.join
@@ -213,7 +213,7 @@ describe Appsignal::Minutely do
     it "clears the probe instances array" do
       Appsignal::Minutely.probes.register :my_probe, lambda {}
       Appsignal::Minutely.start
-      thread = Appsignal::Minutely.class_variable_get(:@@thread)
+      thread = Appsignal::Minutely.instance_variable_get(:@thread)
       wait_for("probes initialized") do
         !Appsignal::Minutely.send(:probe_instances).empty?
       end
@@ -285,19 +285,19 @@ describe Appsignal::Minutely do
     end
 
     describe "#<<" do
-      let(:out_stream) { std_stream }
-      let(:output) { out_stream.read }
+      let(:err_stream) { std_stream }
+      let(:stderr) { err_stream.read }
       let(:log_stream) { std_stream }
       let(:log) { log_contents(log_stream) }
       before { Appsignal.logger = test_logger(log_stream) }
 
       it "adds the probe, but prints a deprecation warning" do
         probe = lambda {}
-        capture_stdout(out_stream) { collection << probe }
+        capture_std_streams(std_stream, err_stream) { collection << probe }
         deprecation_message = "Deprecated " \
           "`Appsignal::Minute.probes <<` call. Please use " \
           "`Appsignal::Minutely.probes.register` instead."
-        expect(output).to include "appsignal WARNING: #{deprecation_message}"
+        expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
         expect(log).to contains_log :warn, deprecation_message
         expect(collection[probe.object_id]).to eql(probe)
       end

data/spec/lib/appsignal/rack/js_exception_catcher_spec.rb

@@ -3,19 +3,37 @@ describe Appsignal::Rack::JSExceptionCatcher do
   let(:options)        { nil }
   let(:config_options) { { :enable_frontend_error_catching => true } }
   let(:config)         { project_fixture_config("production", config_options) }
+  let(:deprecation_message) do
+    "The Appsignal::Rack::JSExceptionCatcher is deprecated. " \
+      "Please use the official AppSignal JavaScript integration instead. " \
+      "https://docs.appsignal.com/front-end/"
+  end
   before { Appsignal.config = config }
 
   describe "#initialize" do
-    it "logs to the logger" do
-      expect(Appsignal.logger).to receive(:debug)
-        .with("Initializing Appsignal::Rack::JSExceptionCatcher")
+    let(:out_stream) { std_stream }
+    let(:err_stream) { std_stream }
+    let(:output) { out_stream.read }
+    let(:stderr) { err_stream.read }
 
-      Appsignal::Rack::JSExceptionCatcher.new(app, options)
+    it "logs to the logger" do
+      log = capture_logs do
+        capture_std_streams(out_stream, err_stream) do
+          Appsignal::Rack::JSExceptionCatcher.new(app, options)
+        end
+      end
+      expect(log).to contains_log(:warn, deprecation_message)
+      expect(log).to contains_log(:debug, "Initializing Appsignal::Rack::JSExceptionCatcher")
+      expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
+      expect(stderr).to_not include("appsignal:")
+      expect(output).to be_empty
     end
   end
 
   describe "#call" do
-    let(:catcher) { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+    let(:catcher) do
+      silence { Appsignal::Rack::JSExceptionCatcher.new(app, options) }
+    end
     after { catcher.call(env) }
 
     context "when path is not frontend_error_catching_path" do

data/spec/lib/appsignal/system_spec.rb

@@ -93,4 +93,40 @@ describe Appsignal::System do
       end
     end
   end
+
+  describe ".ruby_2_or_up?" do
+    around do |example|
+      original_ruby_version = RUBY_VERSION
+      Object.send(:remove_const, "RUBY_VERSION")
+      Object.const_set("RUBY_VERSION", ruby_version)
+      example.run
+      Object.send(:remove_const, "RUBY_VERSION")
+      Object.const_set("RUBY_VERSION", original_ruby_version)
+    end
+    subject { described_class.ruby_2_or_up? }
+
+    context "when on Ruby 1.9" do
+      let(:ruby_version) { "1.9.3-p533" }
+
+      it "returns false" do
+        is_expected.to be(false)
+      end
+    end
+
+    context "when on Ruby 2.0" do
+      let(:ruby_version) { "2.0.0" }
+
+      it "returns true" do
+        is_expected.to be(true)
+      end
+    end
+
+    context "when on Ruby 2.x" do
+      let(:ruby_version) { "2.1.0" }
+
+      it "returns true" do
+        is_expected.to be(true)
+      end
+    end
+  end
 end

data/spec/lib/appsignal/transaction_spec.rb

@@ -64,7 +64,7 @@ describe Appsignal::Transaction do
 
         it "logs a debug message" do
           create_transaction("2")
-          expect(log_contents(log)).to contains_log :debug,
+          expect(log_contents(log)).to contains_log :warn,
             "Trying to start new transaction with id '2', but a " \
             "transaction with id '#{transaction_id}' is already " \
             "running. Using transaction '#{transaction_id}'."
@@ -154,13 +154,8 @@ describe Appsignal::Transaction do
   describe "#complete" do
     context "when transaction is being sampled" do
       it "samples data" do
-        expect(transaction.ext).to receive(:finish).and_return(true)
-        # Stub call to extension, because that would remove the transaction
-        # from the extension.
-        expect(transaction.ext).to receive(:complete)
-
         transaction.set_tags(:foo => "bar")
-        transaction.complete
+        keep_transactions { transaction.complete }
         expect(transaction.to_h["sample_data"]).to include(
           "tags" => { "foo" => "bar" }
         )
@@ -169,11 +164,8 @@ describe Appsignal::Transaction do
 
     context "when transaction is not being sampled" do
       it "does not sample data" do
-        expect(transaction).to_not receive(:sample_data)
-        expect(transaction.ext).to receive(:finish).and_return(false)
-        expect(transaction.ext).to receive(:complete).and_call_original
-
-        transaction.complete
+        keep_transactions(:sample => false) { transaction.complete }
+        expect(transaction.to_h["sample_data"]).to be_empty
       end
     end
 
@@ -449,30 +441,36 @@ describe Appsignal::Transaction do
 
     describe "#set_http_or_background_action" do
       context "for a hash with controller and action" do
-        let(:from) { { :controller => "HomeController", :action => "show" } }
-
-        it "should set the action" do
-          expect(transaction).to receive(:set_action).with("HomeController#show")
+        it "sets the action" do
+          transaction.set_http_or_background_action(
+            :controller => "HomeController",
+            :action => "show"
+          )
+          expect(transaction.to_h["action"]).to eql("HomeController#show")
         end
       end
 
       context "for a hash with just action" do
-        let(:from) { { :action => "show" } }
-
-        it "should set the action" do
-          expect(transaction).to receive(:set_action).with("show")
+        it "sets the action" do
+          transaction.set_http_or_background_action(:action => "show")
+          expect(transaction.to_h["action"]).to eql("show")
         end
       end
 
       context "for a hash with class and method" do
-        let(:from) { { :class => "Worker", :method => "perform" } }
-
-        it "should set the action" do
-          expect(transaction).to receive(:set_action).with("Worker#perform")
+        it "sets the action" do
+          transaction.set_http_or_background_action(:class => "Worker", :method => "perform")
+          expect(transaction.to_h["action"]).to eql("Worker#perform")
         end
       end
 
-      after { transaction.set_http_or_background_action(from) }
+      context "when action is already set" do
+        it "does not overwrite the set action" do
+          transaction.set_action("MyCustomAction#perform")
+          transaction.set_http_or_background_action(:class => "Worker", :method => "perform")
+          expect(transaction.to_h["action"]).to eql("MyCustomAction#perform")
+        end
+      end
     end
 
     describe "set_queue_start" do
@@ -576,7 +574,7 @@ describe Appsignal::Transaction do
       end
 
       context "when the data cannot be converted to JSON" do
-        it "does not update the sample data on the transaction" do
+        it "does not update the sample data on the transaction", :not_ruby19 do
           klass = Class.new do
             def to_s
               raise "foo" # Cause a deliberate error
@@ -588,6 +586,19 @@ describe Appsignal::Transaction do
           expect(log_contents(log)).to contains_log :error,
             "Error generating data (RuntimeError: foo) for"
         end
+
+        it "does not update the sample data on the transaction", :only_ruby19 do
+          klass = Class.new do
+            def to_s
+              raise "foo" # Cause a deliberate error
+            end
+          end
+          transaction.set_sample_data("params", klass.new => 1)
+
+          expect(transaction.to_h["sample_data"]).to eq({})
+          expect(log_contents(log)).to contains_log :error,
+            "Error generating data (RuntimeError: foo). Can't inspect data."
+        end
       end
     end
 

data/spec/lib/appsignal/transmitter_spec.rb

@@ -143,7 +143,9 @@ describe Appsignal::Transmitter do
     context "with a proxy" do
       let(:config) { project_fixture_config("production", :http_proxy => "http://localhost:8080") }
 
-      it { expect(subject).to be_instance_of(Net::HTTP) }
+      it "is of Net::HTTP class", :not_ruby19 do
+        expect(subject).to be_instance_of(Net::HTTP)
+      end
       it { expect(subject.proxy?).to be_truthy }
       it { expect(subject.proxy_address).to eq "localhost" }
       it { expect(subject.proxy_port).to eq 8080 }

data/spec/lib/appsignal_spec.rb

@@ -30,7 +30,7 @@ describe Appsignal do
     context "with no config set beforehand" do
       it "should do nothing when config is not set and there is no valid config in the env" do
         expect(Appsignal.logger).to receive(:error).with(
-          "Push api key not set after loading config"
+          "Push API key not set after loading config"
         ).once
         expect(Appsignal.logger).to receive(:error).with(
           "Not starting, no valid config for this environment"
@@ -701,13 +701,12 @@ describe Appsignal do
       context "when given a block" do
         it "yields the transaction and allows additional metadata to be set" do
           captured_transaction = nil
-          Appsignal.send_error(StandardError.new("my_error")) do |transaction|
-            captured_transaction = transaction
-            transaction.set_action("my_action")
-            transaction.set_namespace("my_namespace")
-
-            # Don't flush the transaction, so we can inspect it
-            expect(transaction).to receive(:complete)
+          keep_transactions do
+            Appsignal.send_error(StandardError.new("my_error")) do |transaction|
+              captured_transaction = transaction
+              transaction.set_action("my_action")
+              transaction.set_namespace("my_namespace")
+            end
           end
           expect(captured_transaction.to_h).to include(
             "namespace" => "my_namespace",
@@ -950,7 +949,7 @@ describe Appsignal do
 
       it "outputs deprecated warning" do
         subject
-        expect(stderr).to include("Appsignal.is_ignored_error? is deprecated with no replacement.")
+        expect(stderr).to include("Appsignal.is_ignored_error? is deprecated with no replacement")
       end
 
       context "when error is not in the ignored list" do
@@ -982,7 +981,7 @@ describe Appsignal do
 
       it "outputs deprecated warning" do
         subject
-        expect(stderr).to include("Appsignal.is_ignored_action? is deprecated with no replacement.")
+        expect(stderr).to include("Appsignal.is_ignored_action? is deprecated with no replacement")
       end
 
       context "when action is not in the ingore list" do
@@ -1022,6 +1021,7 @@ describe Appsignal do
             Appsignal.start_logger
             Appsignal.logger.error("Log to file")
           end
+          expect(Appsignal.logger).to be_a(Appsignal::Logger)
         end
 
         it "logs to file" do
@@ -1044,6 +1044,7 @@ describe Appsignal do
             initialize_config
             Appsignal.start_logger
             Appsignal.logger.error("Log to not writable log file")
+            expect(Appsignal.logger).to be_a(Appsignal::Logger)
           end
         end
 
@@ -1074,6 +1075,7 @@ describe Appsignal do
           Appsignal.start_logger
           Appsignal.logger.error("Log to not writable log path")
         end
+        expect(Appsignal.logger).to be_a(Appsignal::Logger)
       end
       after do
         FileUtils.chmod 0o755, Appsignal::Config.system_tmp_dir
@@ -1102,6 +1104,7 @@ describe Appsignal do
           Appsignal.start_logger
           Appsignal.logger.error("Log to stdout")
         end
+        expect(Appsignal.logger).to be_a(Appsignal::Logger)
       end
       around { |example| recognize_as_heroku { example.run } }