appsignal 2.5.0.alpha.1-java

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

@@ -0,0 +1,174 @@
+if DependencyHelper.que_present?
+  require "appsignal/integrations/que"
+
+  describe Appsignal::Integrations::QuePlugin do
+    describe "#_run" do
+      let(:job_attrs) do
+        {
+          :job_id => 123,
+          :queue => "dfl",
+          :job_class => "MyQueJob",
+          :priority => 100,
+          :args => %w[1 birds],
+          :run_at => fixed_time,
+          :error_count => 0
+        }
+      end
+
+      let(:env) do
+        {
+          :class => "MyQueJob",
+          :method => "run",
+          :metadata => {
+            :id => 123,
+            :queue => "dfl",
+            :priority => 100,
+            :run_at => fixed_time.to_s,
+            :attempts => 0
+          },
+          :params => %w[1 birds]
+        }
+      end
+
+      let(:job) do
+        Class.new(::Que::Job) do
+          def run(*args)
+          end
+        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 }
+
+      context "success" do
+        it "creates a transaction for a job" do
+          expect do
+            instance._run
+          end.to_not raise_exception
+
+          expect(subject).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(
+            "allocation_count" => kind_of(Integer),
+            "body" => "",
+            "body_format" => Appsignal::EventFormatter::DEFAULT,
+            "child_allocation_count" => kind_of(Integer),
+            "child_duration" => kind_of(Float),
+            "child_gc_duration" => kind_of(Float),
+            "count" => 1,
+            "gc_duration" => kind_of(Float),
+            "start" => kind_of(Float),
+            "duration" => kind_of(Float),
+            "name" => "perform_job.que",
+            "title" => ""
+          )
+          expect(subject["sample_data"]).to include(
+            "params" => %w[1 birds],
+            "metadata" => {
+              "attempts" => 0,
+              "id" => 123,
+              "priority" => 100,
+              "queue" => "dfl",
+              "run_at" => fixed_time.to_s
+            }
+          )
+        end
+      end
+
+      context "with exception" do
+        let(:error) { ExampleException.new("oh no!") }
+
+        it "should report 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(
+            "action" => "MyQueJob#run",
+            "id" => instance_of(String),
+            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
+          )
+          expect(subject["error"]).to include(
+            "backtrace" => kind_of(String),
+            "name" => error.class.name,
+            "message" => error.message
+          )
+          expect(subject["sample_data"]).to include(
+            "params" => %w[1 birds],
+            "metadata" => {
+              "attempts" => 0,
+              "id" => 123,
+              "priority" => 100,
+              "queue" => "dfl",
+              "run_at" => fixed_time.to_s
+            }
+          )
+        end
+      end
+
+      context "with error" do
+        let(:error) { ExampleStandardError.new("oh no!") }
+
+        it "should report 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(subject).to include(
+            "action" => "MyQueJob#run",
+            "id" => instance_of(String),
+            "namespace" => Appsignal::Transaction::BACKGROUND_JOB
+          )
+          expect(subject["error"]).to include(
+            "backtrace" => kind_of(String),
+            "name" => error.class.name,
+            "message" => error.message
+          )
+          expect(subject["sample_data"]).to include(
+            "params" => %w[1 birds],
+            "metadata" => {
+              "attempts" => 0,
+              "id" => 123,
+              "priority" => 100,
+              "queue" => "dfl",
+              "run_at" => fixed_time.to_s
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+if DependencyHelper.rails_present?
+  describe Appsignal::Integrations::Railtie do
+    context "after initializing the app" do
+      it "should call initialize_appsignal" do
+        expect(Appsignal::Integrations::Railtie).to receive(:initialize_appsignal)
+
+        MyApp::Application.config.root = project_fixture_path
+        MyApp::Application.initialize!
+      end
+    end
+
+    describe "#initialize_appsignal" do
+      let(:app) { MyApp::Application }
+      before do
+        allow(app.middleware).to receive(:insert_before)
+        allow(app.middleware).to receive(:insert_after)
+      end
+
+      describe ".logger" do
+        before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+        subject { Appsignal.logger }
+
+        it { is_expected.to be_a Logger }
+      end
+
+      describe ".config" do
+        let(:config) { Appsignal.config }
+
+        describe "basic configuration" do
+          before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+
+          it { expect(config).to be_a(Appsignal::Config) }
+
+          it "sets the root_path" do
+            expect(config.root_path).to eq Pathname.new(project_fixture_path)
+          end
+
+          it "sets the detected environment" do
+            expect(config.env).to eq "test"
+          end
+
+          it "loads the app name" do
+            expect(config[:name]).to eq "TestApp"
+          end
+
+          it "sets the log_path based on the root_path" do
+            expect(config[:log_path]).to eq Pathname.new(File.join(project_fixture_path, "log"))
+          end
+        end
+
+        context "with APPSIGNAL_APP_ENV ENV var set" do
+          before do
+            ENV["APPSIGNAL_APP_ENV"] = "env_test"
+            Appsignal::Integrations::Railtie.initialize_appsignal(app)
+          end
+
+          it "uses the environment variable value as the environment" do
+            expect(config.env).to eq "env_test"
+          end
+        end
+      end
+
+      describe ".initial_config" do
+        before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+        let(:config) { Appsignal.config.initial_config }
+
+        it "returns the initial config" do
+          expect(config[:name]).to eq "MyApp"
+        end
+      end
+
+      describe "Rails listener middleware" do
+        it "adds the Rails listener middleware" do
+          expect(app.middleware).to receive(:insert_after).with(
+            ActionDispatch::DebugExceptions,
+            Appsignal::Rack::RailsInstrumentation
+          )
+        end
+
+        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+      end
+
+      describe "frontend_error_catching middleware" do
+        let(:config) do
+          Appsignal::Config.new(
+            project_fixture_path,
+            "test",
+            :name => "MyApp",
+            :enable_frontend_error_catching => enable_frontend_error_catching
+          )
+        end
+        before { allow(Appsignal::Config).to receive(:new).and_return(config) }
+        after { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+
+        context "when enabled" do
+          let(:enable_frontend_error_catching) { true }
+
+          it "adds the Rails and JSExceptionCatcher middleware" do
+            expect(app.middleware).to receive(:insert_after).with(
+              ActionDispatch::DebugExceptions,
+              Appsignal::Rack::RailsInstrumentation
+            )
+
+            expect(app.middleware).to receive(:insert_before).with(
+              Appsignal::Rack::RailsInstrumentation,
+              Appsignal::Rack::JSExceptionCatcher
+            )
+          end
+        end
+
+        context "when not enabled" do
+          let(:enable_frontend_error_catching) { false }
+
+          it "adds the Rails middleware, but not the JSExceptionCatcher middleware" do
+            expect(app.middleware).to receive(:insert_after).with(
+              ActionDispatch::DebugExceptions,
+              Appsignal::Rack::RailsInstrumentation
+            )
+
+            expect(app.middleware).to_not receive(:insert_before).with(
+              Appsignal::Rack::RailsInstrumentation,
+              Appsignal::Rack::JSExceptionCatcher
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+if DependencyHelper.resque_present? && DependencyHelper.active_job_present?
+  require "active_job"
+
+  describe Appsignal::Integrations::ResqueActiveJobPlugin do
+    let(:file) { File.expand_path("lib/appsignal/integrations/resque_active_job.rb") }
+    let(:args) { "argument" }
+    let(:job) { TestActiveJob.new(args) }
+    before do
+      load file
+      start_agent
+
+      class TestActiveJob < ActiveJob::Base
+        include Appsignal::Integrations::ResqueActiveJobPlugin
+
+        def perform(_)
+        end
+      end
+    end
+
+    it "wraps it in a transaction with the correct params" do
+      expect(Appsignal).to receive(:monitor_single_transaction).with(
+        "perform_job.resque",
+        :class  => "TestActiveJob",
+        :method => "perform",
+        :params => ["argument"],
+        :metadata => {
+          :id    => kind_of(String),
+          :queue => "default"
+        }
+      )
+    end
+
+    context "with complex arguments" do
+      let(:args) do
+        {
+          :foo => "Foo",
+          :bar => "Bar"
+        }
+      end
+
+      it "truncates large argument values" do
+        expect(Appsignal).to receive(:monitor_single_transaction).with(
+          "perform_job.resque",
+          :class  => "TestActiveJob",
+          :method => "perform",
+          :params => [
+            :foo => "Foo",
+            :bar => "Bar"
+          ],
+          :metadata => {
+            :id    => kind_of(String),
+            :queue => "default"
+          }
+        )
+      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_single_transaction).with(
+            "perform_job.resque",
+            :class  => "TestActiveJob",
+            :method => "perform",
+            :params => [
+              :foo => "[FILTERED]",
+              :bar => "Bar"
+            ],
+            :metadata => {
+              :id    => kind_of(String),
+              :queue => "default"
+            }
+          )
+        end
+      end
+    end
+
+    after { job.perform_now }
+  end
+end

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

@@ -0,0 +1,92 @@
+if DependencyHelper.resque_present?
+  describe "Resque integration" do
+    let(:file) { File.expand_path("lib/appsignal/integrations/resque.rb") }
+
+    context "with resque" do
+      before do
+        load file
+        start_agent
+
+        class TestJob
+          extend Appsignal::Integrations::ResquePlugin
+
+          def self.perform
+          end
+        end
+
+        class BrokenTestJob
+          extend Appsignal::Integrations::ResquePlugin
+
+          def self.perform
+            raise ExampleException
+          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
+
+        context "without exception" do
+          it "creates a new transaction" do
+            expect(Appsignal::Transaction).to receive(:create).and_return(transaction)
+          end
+
+          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"
+            )
+          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)
+          end
+
+          it "sets the exception on the transaction" do
+            expect(transaction).to receive(:set_error).with(ExampleException)
+          end
+
+          after do
+            expect { job.perform }.to raise_error(ExampleException)
+          end
+        end
+      end
+    end
+
+    context "without resque" do
+      before(:context) { Object.send(:remove_const, :Resque) }
+
+      it { expect { ::Resque }.to raise_error(NameError) }
+      it { expect { load file }.to_not raise_error }
+    end
+  end
+end