appsignal 2.11.10 → 3.0.0.beta.1

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

@@ -1,266 +0,0 @@
-require "appsignal/integrations/object"
-
-def is_ruby_19
-  RUBY_VERSION < "2.0"
-end
-
-describe Object do
-  describe "#instrument_method" do
-    context "with instance method" do
-      let(:klass) do
-        Class.new do
-          def foo(param1, options = {})
-            [param1, options]
-          end
-          appsignal_instrument_method :foo
-        end
-      end
-      let(:instance) { klass.new }
-
-      def call_with_arguments
-        instance.foo(
-          "abc",
-          :foo => "bar"
-        )
-      end
-
-      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)
-        end
-        after { Appsignal.config = nil }
-
-        context "with anonymous class" do
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-          end
-        end
-
-        context "with named class" do
-          before do
-            class NamedClass
-              def foo
-                1
-              end
-              appsignal_instrument_method :foo
-            end
-          end
-          after { Object.send(:remove_const, :NamedClass) }
-          let(:klass) { NamedClass }
-
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
-          end
-        end
-
-        context "with nested named class" do
-          before do
-            module MyModule
-              module NestedModule
-                class NamedClass
-                  def bar
-                    2
-                  end
-                  appsignal_instrument_method :bar
-                end
-              end
-            end
-          end
-          after { Object.send(:remove_const, :MyModule) }
-          let(:klass) { MyModule::NestedModule::NamedClass }
-
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
-              Appsignal::EventFormatter::DEFAULT
-            expect(instance.bar).to eq(2)
-          end
-        end
-
-        context "with custom name" do
-          let(:klass) do
-            Class.new do
-              def foo
-                1
-              end
-              appsignal_instrument_method :foo, :name => "my_method.group"
-            end
-          end
-
-          it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(instance.foo).to eq(1)
-          end
-        end
-
-        context "with a method given a block" do
-          let(:klass) do
-            Class.new do
-              def foo
-                yield
-              end
-              appsignal_instrument_method :foo
-            end
-          end
-
-          it "should yield the block" do
-            expect(instance.foo { 42 }).to eq(42)
-          end
-        end
-      end
-
-      context "when not active" do
-        let(:transaction) { Appsignal::Transaction.current }
-
-        it "does not instrument, but still calls the method" do
-          expect(Appsignal.active?).to be_falsy
-          expect(transaction).to_not receive(:start_event)
-          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-        end
-      end
-    end
-
-    context "with class method" do
-      let(:klass) do
-        Class.new do
-          def self.bar(param1, options = {})
-            [param1, options]
-          end
-          appsignal_instrument_class_method :bar
-        end
-      end
-      def call_with_arguments
-        klass.bar(
-          "abc",
-          :foo => "bar"
-        )
-      end
-
-      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)
-        end
-        after { Appsignal.config = nil }
-
-        context "with anonymous class" do
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-          end
-        end
-
-        context "with named class" do
-          before do
-            class NamedClass
-              def self.bar
-                2
-              end
-              appsignal_instrument_class_method :bar
-            end
-          end
-          after { Object.send(:remove_const, :NamedClass) }
-          let(:klass) { NamedClass }
-
-          it "instruments the method and calls it" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
-          end
-
-          context "with nested named class" do
-            before do
-              module MyModule
-                module NestedModule
-                  class NamedClass
-                    def self.bar
-                      2
-                    end
-                    appsignal_instrument_class_method :bar
-                  end
-                end
-              end
-            end
-            after { Object.send(:remove_const, :MyModule) }
-            let(:klass) { MyModule::NestedModule::NamedClass }
-
-            it "instruments the method and calls it" do
-              expect(Appsignal.active?).to be_truthy
-              expect(transaction).to receive(:start_event)
-              expect(transaction).to receive(:finish_event).with \
-                "bar.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
-                Appsignal::EventFormatter::DEFAULT
-              expect(klass.bar).to eq(2)
-            end
-          end
-        end
-
-        context "with custom name" do
-          let(:klass) do
-            Class.new do
-              def self.bar
-                2
-              end
-              appsignal_instrument_class_method :bar, :name => "my_method.group"
-            end
-          end
-
-          it "instruments with custom name" do
-            expect(Appsignal.active?).to be_truthy
-            expect(transaction).to receive(:start_event)
-            expect(transaction).to receive(:finish_event).with \
-              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
-            expect(klass.bar).to eq(2)
-          end
-        end
-
-        context "with a method given a block" do
-          let(:klass) do
-            Class.new do
-              def self.bar
-                yield
-              end
-              appsignal_instrument_class_method :bar
-            end
-          end
-
-          it "should yield the block" do
-            expect(klass.bar { 42 }).to eq(42)
-          end
-        end
-      end
-
-      context "when not active" do
-        let(:transaction) { Appsignal::Transaction.current }
-
-        it "does not instrument, but still call the method" do
-          expect(Appsignal.active?).to be_falsy
-          expect(transaction).to_not receive(:start_event)
-          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "appsignal/integrations/resque_active_job"
-
-describe "Legacy Resque ActiveJob integration" do
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-  let(:log_stream) { std_stream }
-  let(:log) { log_contents(log_stream) }
-
-  it "logs and prints a deprecation message on extend" do
-    Appsignal.logger = test_logger(log_stream)
-
-    capture_std_streams(std_stream, err_stream) do
-      Class.new do
-        include Appsignal::Integrations::ResqueActiveJobPlugin
-      end
-    end
-
-    deprecation_message =
-      "The AppSignal ResqueActiveJobPlugin is deprecated and does " \
-      "nothing on extend. In this version of the AppSignal Ruby gem " \
-      "the integration with Resque is automatic on all Resque workers. " \
-      "Please remove the following line from this file to remove this " \
-      "message: include Appsignal::Integrations::ResqueActiveJobPlugin\n" \
-      "#{__FILE__}:"
-    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-    expect(log).to contains_log :warn, deprecation_message
-  end
-end

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

@@ -1,28 +0,0 @@
-require "appsignal/integrations/resque"
-
-describe "Legacy Resque integration" do
-  let(:err_stream) { std_stream }
-  let(:stderr) { err_stream.read }
-  let(:log_stream) { std_stream }
-  let(:log) { log_contents(log_stream) }
-
-  it "logs and prints a deprecation message on extend" do
-    Appsignal.logger = test_logger(log_stream)
-
-    capture_std_streams(std_stream, err_stream) do
-      Class.new do
-        extend Appsignal::Integrations::ResquePlugin
-      end
-    end
-
-    deprecation_message =
-      "The AppSignal ResquePlugin is deprecated and does " \
-      "nothing on extend. In this version of the AppSignal Ruby gem " \
-      "the integration with Resque is automatic on all Resque workers. " \
-      "Please remove the following line from this file to remove this " \
-      "message: extend Appsignal::Integrations::ResquePlugin\n" \
-      "#{__FILE__}:"
-    expect(stderr).to include "appsignal WARNING: #{deprecation_message}"
-    expect(log).to contains_log :warn, deprecation_message
-  end
-end

data/spec/lib/appsignal/js_exception_transaction_spec.rb

@@ -1,128 +0,0 @@
-describe Appsignal::JSExceptionTransaction do
-  before { allow(SecureRandom).to receive(:uuid).and_return("123abc") }
-
-  let!(:transaction) { Appsignal::JSExceptionTransaction.new(data) }
-  let(:data) do
-    {
-      "name"        => "TypeError",
-      "message"     => "foo is not a valid method",
-      "action"      => "ExceptionIncidentComponent",
-      "path"        => "foo.bar/moo",
-      "environment" => "development",
-      "backtrace"   => [
-        "foo.bar/js:11:1",
-        "foo.bar/js:22:2"
-      ],
-      "tags" => [
-        "tag1"
-      ]
-    }
-  end
-
-  describe "#initialize" do
-    it "should call all required methods" do
-      expect(Appsignal::Extension).to receive(:start_transaction).with("123abc", "frontend", 0).and_return(1)
-
-      expect(transaction).to receive(:set_action)
-      expect(transaction).to receive(:set_metadata)
-      expect(transaction).to receive(:set_error)
-      expect(transaction).to receive(:set_sample_data)
-
-      transaction.send :initialize, data
-
-      expect(transaction.ext).to_not be_nil
-    end
-  end
-
-  describe "#set_action" do
-    it "should call `Appsignal::Extension.set_action`" do
-      expect(transaction.ext).to receive(:set_action).with(
-        "ExceptionIncidentComponent"
-      )
-
-      transaction.set_action
-    end
-  end
-
-  describe "#set_metadata" do
-    it "should call `Appsignal::Extension.set_transaction_metadata`" do
-      expect(transaction.ext).to receive(:set_metadata).with(
-        "path",
-        "foo.bar/moo"
-      )
-
-      transaction.set_metadata
-    end
-  end
-
-  describe "#set_error" do
-    it "should call `Appsignal::Extension.set_transaction_error`" do
-      expect(transaction.ext).to receive(:set_error).with(
-        "TypeError",
-        "foo is not a valid method",
-        Appsignal::Utils::Data.generate(["foo.bar/js:11:1", "foo.bar/js:22:2"])
-      )
-
-      transaction.set_error
-    end
-  end
-
-  describe "#set_sample_data" do
-    it "should call `Appsignal::Extension.set_transaction_error_data`" do
-      expect(transaction.ext).to receive(:set_sample_data).with(
-        "tags",
-        Appsignal::Utils::Data.generate(["tag1"])
-      )
-
-      transaction.set_sample_data
-    end
-  end
-
-  context "when sending just the name" do
-    let(:data) { { "name" => "TypeError" } }
-
-    describe "#set_action" do
-      it "should not call `Appsignal::Extension.set_action`" do
-        expect(transaction.ext).to_not receive(:set_action)
-
-        transaction.set_action
-      end
-    end
-
-    describe "#set_metadata" do
-      it "should not call `Appsignal::Extension.set_transaction_metadata`" do
-        expect(transaction.ext).to_not receive(:set_metadata)
-
-        transaction.set_metadata
-      end
-    end
-
-    describe "#set_error" do
-      it "should call `Appsignal::Extension.set_transaction_error` with just the name" do
-        expect(transaction.ext).to receive(:set_error).with(
-          "TypeError",
-          "",
-          Appsignal::Utils::Data.generate([])
-        )
-
-        transaction.set_error
-      end
-    end
-
-    describe "#set_sample_data" do
-      it "should not call `Appsignal::Extension.set_transaction_error_data`" do
-        expect(transaction.ext).to_not receive(:set_sample_data)
-
-        transaction.set_sample_data
-      end
-    end
-  end
-
-  describe "#complete!" do
-    it "should call all required methods" do
-      expect(transaction.ext).to receive(:finish).and_call_original
-      expect(transaction.ext).to receive(:complete).and_call_original
-      transaction.complete!
-    end
-  end
-end

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

@@ -1,170 +0,0 @@
-describe Appsignal::Rack::JSExceptionCatcher do
-  let(:app)            { double(:call => true) }
-  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 and will be removed in a future version. Please use " \
-      "the official AppSignal JavaScript integration by disabling " \
-      "`enable_frontend_error_catching` in your configuration and " \
-      "installing AppSignal for JavaScript instead. " \
-      "(https://docs.appsignal.com/front-end/)"
-  end
-  before { Appsignal.config = config }
-
-  describe "#initialize" do
-    let(:out_stream) { std_stream }
-    let(:err_stream) { std_stream }
-    let(:output) { out_stream.read }
-    let(:stderr) { err_stream.read }
-
-    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) do
-      silence :allowed => ["enable_frontend_error_catching"] do
-        Appsignal::Rack::JSExceptionCatcher.new(app, options)
-      end
-    end
-    after { catcher.call(env) }
-
-    context "when path is not frontend_error_catching_path" do
-      let(:env) { { "PATH_INFO" => "/foo" } }
-
-      context "when AppSignal is not active" do
-        before { config[:active] = false }
-
-        it "calls the next middleware" do
-          expect(app).to receive(:call).with(env)
-        end
-      end
-
-      context "when AppSignal is active" do
-        before { config[:active] = true }
-
-        it "calls the next middleware" do
-          expect(app).to receive(:call).with(env)
-        end
-      end
-    end
-
-    context "when path is frontend_error_catching_path" do
-      let(:transaction) { double(:complete! => true) }
-      let(:env) do
-        {
-          "PATH_INFO"  => "/appsignal_error_catcher",
-          "rack.input" => double(:read => '{"name": "error"}')
-        }
-      end
-
-      context "when AppSignal is not active" do
-        before { config[:active] = false }
-
-        it "doesn't create an AppSignal transaction" do
-          expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-        end
-
-        it "returns a 202 status" do
-          expect(catcher.call(env)).to eq(
-            [202, {}, ["AppSignal JavaScript error catching endpoint is not active."]]
-          )
-        end
-      end
-
-      context "when AppSignal is active" do
-        before { config[:active] = true }
-
-        it "creates a JSExceptionTransaction" do
-          expect(Appsignal::JSExceptionTransaction).to receive(:new)
-            .with("name" => "error")
-            .and_return(transaction)
-
-          expect(transaction).to receive(:complete!)
-        end
-
-        it "returns 200" do
-          allow(Appsignal::JSExceptionTransaction).to receive(:new)
-            .and_return(transaction)
-
-          expect(catcher.call(env)).to eq([200, {}, []])
-        end
-
-        context "when request payload is empty" do
-          let(:env) do
-            {
-              "PATH_INFO"  => "/appsignal_error_catcher",
-              "rack.input" => double(:read => "")
-            }
-          end
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "returns 400" do
-            expect(catcher.call(env)).to eq([400, {}, ["Request payload is not valid JSON."]])
-          end
-        end
-
-        context "when `frontend_error_catching_path` is different" do
-          let(:config_options) { { :frontend_error_catching_path => "/foo" } }
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "calls the next middleware" do
-            expect(app).to receive(:call).with(env)
-          end
-        end
-
-        context "when `name` is empty" do
-          let(:env) do
-            {
-              "PATH_INFO"  => "/appsignal_error_catcher",
-              "rack.input" => double(:read => '{"name": ""}')
-            }
-          end
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "returns 422" do
-            expect(catcher.call(env)).to eq([422, {}, []])
-          end
-        end
-
-        context "when `name` doesn't exist" do
-          let(:env) do
-            {
-              "PATH_INFO"  => "/appsignal_error_catcher",
-              "rack.input" => double(:read => '{"foo": ""}')
-            }
-          end
-
-          it "does not create a transaction" do
-            expect(Appsignal::JSExceptionTransaction).to_not receive(:new)
-          end
-
-          it "returns 422" do
-            expect(catcher.call(env)).to eq([422, {}, []])
-          end
-        end
-      end
-    end
-  end
-end