appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,92 @@
+describe Appsignal::Hooks::ActiveSupportNotificationsHook do
+  if active_support_present?
+    let(:notifier) { ActiveSupport::Notifications::Fanout.new }
+    let(:as) { ActiveSupport::Notifications }
+    before :context do
+      start_agent
+    end
+    before do
+      as.notifier = notifier
+      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "instruments an ActiveSupport::Notifications.instrument event" do
+      expect(Appsignal::Transaction.current).to receive(:start_event)
+        .at_least(:once)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
+        .at_least(:once)
+        .with("sql.active_record", nil, "SQL", 1)
+
+      return_value = as.instrument("sql.active_record", :sql => "SQL") do
+        "value"
+      end
+
+      expect(return_value).to eq "value"
+    end
+
+    it "should convert non-string names to strings" do
+      expect(Appsignal::Transaction.current).to receive(:start_event)
+        .at_least(:once)
+      expect(Appsignal::Transaction.current).to receive(:finish_event)
+        .at_least(:once)
+        .with("not_a_string", nil, nil, nil)
+
+      as.instrument(:not_a_string) {}
+    end
+
+    it "does not instrument events whose name starts with a bang" do
+      expect(Appsignal::Transaction.current).not_to receive(:start_event)
+      expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+      return_value = as.instrument("!sql.active_record", :sql => "SQL") do
+        "value"
+      end
+
+      expect(return_value).to eq "value"
+    end
+
+    context "when an error is raised in an instrumented block" do
+      it "instruments an ActiveSupport::Notifications.instrument event" do
+        expect(Appsignal::Transaction.current).to receive(:start_event)
+          .at_least(:once)
+        expect(Appsignal::Transaction.current).to receive(:finish_event)
+          .at_least(:once)
+          .with("sql.active_record", nil, "SQL", 1)
+
+        expect do
+          as.instrument("sql.active_record", :sql => "SQL") do
+            raise ExampleException, "foo"
+          end
+        end.to raise_error(ExampleException, "foo")
+      end
+    end
+
+    context "when a message is thrown in an instrumented block" do
+      it "instruments an ActiveSupport::Notifications.instrument event" do
+        expect(Appsignal::Transaction.current).to receive(:start_event)
+          .at_least(:once)
+        expect(Appsignal::Transaction.current).to receive(:finish_event)
+          .at_least(:once)
+          .with("sql.active_record", nil, "SQL", 1)
+
+        expect do
+          as.instrument("sql.active_record", :sql => "SQL") do
+            throw :foo
+          end
+        end.to throw_symbol(:foo)
+      end
+    end
+  else
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+describe Appsignal::Hooks::CelluloidHook do
+  context "with celluloid" do
+    before :context do
+      module Celluloid
+        def self.shutdown
+        end
+      end
+      Appsignal::Hooks::CelluloidHook.new.install
+    end
+    after :context do
+      Object.send(:remove_const, :Celluloid)
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    specify { expect(Appsignal).to receive(:stop) }
+    specify { expect(Celluloid).to receive(:shutdown_without_appsignal) }
+
+    after do
+      Celluloid.shutdown
+    end
+  end
+
+  context "without celluloid" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+describe Appsignal::Hooks::DataMapperHook do
+  context "with datamapper" do
+    before :context do
+      module DataMapper
+      end
+      module DataObjects
+        class Connection
+        end
+      end
+      Appsignal::Hooks::DataMapperHook.new.install
+    end
+
+    after :context do
+      Object.send(:remove_const, :DataMapper)
+      Object.send(:remove_const, :DataObjects)
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "should install the listener" do
+      expect(::DataObjects::Connection).to receive(:include)
+        .with(Appsignal::Hooks::DataMapperLogListener)
+
+      Appsignal::Hooks::DataMapperHook.new.install
+    end
+  end
+
+  context "without datamapper" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -0,0 +1,358 @@
+describe Appsignal::Hooks::DelayedJobHook do
+  context "with delayed job" do
+    before(:context) do
+      module Delayed
+        class Plugin
+          def self.callbacks
+          end
+        end
+
+        class Worker
+          def self.plugins
+            @plugins ||= []
+          end
+        end
+      end
+    end
+    after(:context) { Object.send(:remove_const, :Delayed) }
+    before do
+      start_agent
+    end
+
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "adds the plugin" do
+      expect(::Delayed::Worker.plugins).to include Appsignal::Hooks::DelayedJobPlugin
+    end
+
+    # We haven't found a way to test the hooks, we'll have to do that manually
+
+    describe ".invoke_with_instrumentation" do
+      let(:plugin) { Appsignal::Hooks::DelayedJobPlugin }
+      let(:time) { Time.parse("01-01-2001 10:01:00UTC") }
+      let(:created_at) { time - 3600 }
+      let(:run_at) { time - 3600 }
+      let(:job_data) do
+        {
+          :id             => 123,
+          :name           => "TestClass#perform",
+          :priority       => 1,
+          :attempts       => 1,
+          :queue          => "default",
+          :created_at     => created_at,
+          :run_at         => run_at,
+          :payload_object => double(:args => args)
+        }
+      end
+      let(:args) { ["argument"] }
+      let(:job) { double(job_data) }
+      let(:invoked_block) { proc {} }
+
+      context "with a normal call" do
+        let(:default_params) do
+          {
+            :class    => "TestClass",
+            :method   => "perform",
+            :metadata => {
+              :priority => 1,
+              :attempts => 1,
+              :queue    => "default",
+              :id       => "123"
+            },
+            :params      => args,
+            :queue_start => run_at
+          }
+        end
+        after do
+          Timecop.freeze(time) do
+            plugin.invoke_with_instrumentation(job, invoked_block)
+          end
+        end
+
+        it "wraps it in a transaction with the correct params" do
+          expect(Appsignal).to receive(:monitor_transaction).with(
+            "perform_job.delayed_job",
+            default_params.merge(:params => ["argument"])
+          )
+        end
+
+        context "with more complex params" do
+          let(:args) do
+            {
+              :foo => "Foo",
+              :bar => "Bar"
+            }
+          end
+
+          it "adds the more complex arguments" do
+            expect(Appsignal).to receive(:monitor_transaction).with(
+              "perform_job.delayed_job",
+              default_params.merge(
+                :params => {
+                  :foo => "Foo",
+                  :bar => "Bar"
+                }
+              )
+            )
+          end
+
+          context "with parameter filtering" do
+            before do
+              Appsignal.config = project_fixture_config("production")
+              Appsignal.config[:filter_parameters] = ["foo"]
+            end
+
+            it "filters selected arguments" do
+              expect(Appsignal).to receive(:monitor_transaction).with(
+                "perform_job.delayed_job",
+                default_params.merge(
+                  :params => {
+                    :foo => "[FILTERED]",
+                    :bar => "Bar"
+                  }
+                )
+              )
+            end
+          end
+        end
+
+        context "with run_at in the future" do
+          let(:run_at) { Time.parse("2017-01-01 10:01:00UTC") }
+
+          it "reports queue_start with run_at time" do
+            expect(Appsignal).to receive(:monitor_transaction).with(
+              "perform_job.delayed_job",
+              default_params.merge(:queue_start => run_at)
+            )
+          end
+        end
+
+        context "with custom name call" do
+          let(:job_data) do
+            {
+              :payload_object => double(
+                :appsignal_name => "CustomClass#perform",
+                :args           => args
+              ),
+              :id         => "123",
+              :name       => "TestClass#perform",
+              :priority   => 1,
+              :attempts   => 1,
+              :queue      => "default",
+              :created_at => created_at,
+              :run_at     => run_at
+            }
+          end
+          let(:default_params) do
+            {
+              :class => "CustomClass",
+              :method => "perform",
+              :metadata => {
+                :priority => 1,
+                :attempts => 1,
+                :queue    => "default",
+                :id       => "123"
+              },
+              :queue_start => run_at
+            }
+          end
+
+          it "wraps it in a transaction with the correct params" do
+            expect(Appsignal).to receive(:monitor_transaction).with(
+              "perform_job.delayed_job",
+              default_params.merge(
+                :params => ["argument"]
+              )
+            )
+          end
+
+          context "with more complex params" do
+            let(:args) do
+              {
+                :foo => "Foo",
+                :bar => "Bar"
+              }
+            end
+
+            it "adds the more complex arguments" do
+              expect(Appsignal).to receive(:monitor_transaction).with(
+                "perform_job.delayed_job",
+                default_params.merge(
+                  :params => {
+                    :foo => "Foo",
+                    :bar => "Bar"
+                  }
+                )
+              )
+            end
+
+            context "with parameter filtering" do
+              before do
+                Appsignal.config = project_fixture_config("production")
+                Appsignal.config[:filter_parameters] = ["foo"]
+              end
+
+              it "filters selected arguments" do
+                expect(Appsignal).to receive(:monitor_transaction).with(
+                  "perform_job.delayed_job",
+                  default_params.merge(
+                    :params => {
+                      :foo => "[FILTERED]",
+                      :bar => "Bar"
+                    }
+                  )
+                )
+              end
+            end
+          end
+        end
+
+        if active_job_present?
+          require "active_job"
+
+          context "when wrapped by ActiveJob" do
+            let(:wrapped_job) do
+              ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(
+                "arguments"  => args,
+                "job_class"  => "TestClass",
+                "job_id"     => 123,
+                "locale"     => :en,
+                "queue_name" => "default"
+              )
+            end
+            let(:job) do
+              double(
+                :id             => 123,
+                :name           => "ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper",
+                :priority       => 1,
+                :attempts       => 1,
+                :queue          => "default",
+                :created_at     => created_at,
+                :run_at         => run_at,
+                :payload_object => wrapped_job
+              )
+            end
+            let(:default_params) do
+              {
+                :class    => "TestClass",
+                :method   => "perform",
+                :metadata => {
+                  :priority => 1,
+                  :attempts => 1,
+                  :queue    => "default",
+                  :id       => "123"
+                },
+                :queue_start => run_at,
+                :params      => args
+              }
+            end
+            let(:args) { ["activejob_argument"] }
+
+            context "with simple params" do
+              it "wraps it in a transaction with the correct params" do
+                expect(Appsignal).to receive(:monitor_transaction).with(
+                  "perform_job.delayed_job",
+                  default_params.merge(:params => ["activejob_argument"])
+                )
+              end
+            end
+
+            context "with more complex params" do
+              let(:args) do
+                {
+                  :foo => "Foo",
+                  :bar => "Bar"
+                }
+              end
+
+              it "adds the more complex arguments" do
+                expect(Appsignal).to receive(:monitor_transaction).with(
+                  "perform_job.delayed_job",
+                  default_params.merge(
+                    :params => {
+                      :foo => "Foo",
+                      :bar => "Bar"
+                    }
+                  )
+                )
+              end
+
+              context "with parameter filtering" do
+                before do
+                  Appsignal.config = project_fixture_config("production")
+                  Appsignal.config[:filter_parameters] = ["foo"]
+                end
+
+                it "filters selected arguments" do
+                  expect(Appsignal).to receive(:monitor_transaction).with(
+                    "perform_job.delayed_job",
+                    default_params.merge(
+                      :params => {
+                        :foo => "[FILTERED]",
+                        :bar => "Bar"
+                      }
+                    )
+                  )
+                end
+              end
+            end
+
+            context "with run_at in the future" do
+              let(:run_at) { Time.parse("2017-01-01 10:01:00UTC") }
+
+              it "reports queue_start with run_at time" do
+                expect(Appsignal).to receive(:monitor_transaction).with(
+                  "perform_job.delayed_job",
+                  default_params.merge(:queue_start => run_at)
+                )
+              end
+            end
+          end
+        end
+      end
+
+      context "with an erroring call" do
+        let(:error) { ExampleException }
+        let(:transaction) do
+          Appsignal::Transaction.new(
+            SecureRandom.uuid,
+            Appsignal::Transaction::BACKGROUND_JOB,
+            Appsignal::Transaction::GenericRequest.new({})
+          )
+        end
+        before do
+          expect(invoked_block).to receive(:call).and_raise(error)
+
+          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)
+        end
+
+        it "adds the error to the transaction" do
+          expect(transaction).to receive(:set_error).with(error)
+          expect(transaction).to receive(:complete)
+
+          expect do
+            plugin.invoke_with_instrumentation(job, invoked_block)
+          end.to raise_error(error)
+        end
+      end
+    end
+  end
+
+  context "without delayed job" do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end