appsignal 2.11.0.alpha.2 → 2.11.0.beta.5

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

@@ -227,25 +227,14 @@ describe Appsignal::Hooks::DelayedJobHook do
           end
         end
 
-        context "without job name" do
-          let(:job_data) do
-            { :name => "", :payload_object => payload_object }
-          end
-
-          it "wraps it in a transaction using the class method job name" do
-            perform
-            expect(last_transaction.to_h["action"]).to eql("unknown")
-          end
-        end
-
-        context "with invalid job name" do
+        context "with only job class name" do
           let(:job_data) do
             { :name => "Banana", :payload_object => payload_object }
           end
 
-          it "wraps it in a transaction using the class method job name" do
+          it "appends #perform to the class name" do
             perform
-            expect(last_transaction.to_h["action"]).to eql("unknown")
+            expect(last_transaction.to_h["action"]).to eql("Banana#perform")
           end
         end
 

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

@@ -0,0 +1,185 @@
+describe Appsignal::Hooks::ResqueHook do
+  describe "#dependency_present?" do
+    subject { described_class.new.dependencies_present? }
+
+    context "when Resque is loaded" do
+      before { stub_const "Resque", 1 }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when Resque is not loaded" do
+      before { hide_const "Resque" }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  if DependencyHelper.resque_present?
+    describe "#install" do
+      def perform_job(klass, options = {})
+        payload = { "class" => klass.to_s }.merge(options)
+        job = ::Resque::Job.new(queue, payload)
+        keep_transactions { job.perform }
+      end
+
+      let(:queue) { "default" }
+      let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+      before do
+        start_agent
+
+        class ResqueTestJob
+          def self.perform(*_args)
+          end
+        end
+
+        class ResqueErrorTestJob
+          def self.perform
+            raise "resque job error"
+          end
+        end
+
+        expect(Appsignal).to receive(:stop) # Resque calls stop after every job
+      end
+      around do |example|
+        keep_transactions { example.run }
+      end
+      after do
+        Object.send(:remove_const, :ResqueTestJob)
+        Object.send(:remove_const, :ResqueErrorTestJob)
+      end
+
+      it "tracks a transaction on perform" do
+        perform_job(ResqueTestJob)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "id" => kind_of(String),
+          "action" => "ResqueTestJob#perform",
+          "error" => nil,
+          "namespace" => namespace,
+          "metadata" => {},
+          "sample_data" => { "tags" => { "queue" => queue } }
+        )
+        expect(transaction_hash["events"].map { |e| e["name"] })
+          .to eql(["perform.resque"])
+      end
+
+      context "with error" do
+        it "tracks the error on the transaction" do
+          expect do
+            perform_job(ResqueErrorTestJob)
+          end.to raise_error(RuntimeError, "resque job error")
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "ResqueErrorTestJob#perform",
+            "error" => {
+              "name" => "RuntimeError",
+              "message" => "resque job error",
+              "backtrace" => kind_of(String)
+            },
+            "namespace" => namespace,
+            "metadata" => {},
+            "sample_data" => { "tags" => { "queue" => queue } }
+          )
+        end
+      end
+
+      context "with arguments" do
+        before do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        end
+
+        it "filters out configured arguments" do
+          perform_job(
+            ResqueTestJob,
+            "args" => [
+              "foo",
+              {
+                "foo" => "secret",
+                "bar" => "Bar",
+                "baz" => { "1" => "foo" }
+              }
+            ]
+          )
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "ResqueTestJob#perform",
+            "error" => nil,
+            "namespace" => namespace,
+            "metadata" => {},
+            "sample_data" => {
+              "tags" => { "queue" => queue },
+              "params" => [
+                "foo",
+                {
+                  "foo" => "[FILTERED]",
+                  "bar" => "Bar",
+                  "baz" => { "1" => "foo" }
+                }
+              ]
+            }
+          )
+        end
+      end
+
+      context "with active job" do
+        before do
+          module ActiveJobMock
+            module QueueAdapters
+              module ResqueAdapter
+                module JobWrapper
+                  class << self
+                    def perform(job_data)
+                      # Basic ActiveJob stub for this test.
+                      # I haven't found a way to run Resque in a testing mode.
+                      Appsignal.set_action(job_data["job_class"])
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          stub_const "ActiveJob", ActiveJobMock
+        end
+        after { Object.send(:remove_const, :ActiveJobMock) }
+
+        it "does not set arguments but lets the ActiveJob intergration handle it" do
+          perform_job(
+            ResqueTestJob,
+            "class" => "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper",
+            "args" => [
+              {
+                "job_class" => "ResqueTestJobByActiveJob#perform",
+                "arguments" => ["an argument", "second argument"]
+              }
+            ]
+          )
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "ResqueTestJobByActiveJob#perform",
+            "error" => nil,
+            "namespace" => namespace,
+            "metadata" => {},
+            "sample_data" => {
+              "tags" => { "queue" => queue }
+              # Params will be set by the ActiveJob integration
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,54 @@
+describe Appsignal::Hooks::SidekiqHook do
+  describe "#dependencies_present?" do
+    subject { described_class.new.dependencies_present? }
+
+    context "when Sidekiq constant is found" do
+      before { stub_const "Sidekiq", Class.new }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when Sidekiq constant is not found" do
+      before { hide_const "Sidekiq" }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+
+  describe "#install" do
+    class SidekiqMiddlewareMock < Set
+      def exists?(middleware)
+        include?(middleware)
+      end
+    end
+    module SidekiqMock
+      def self.middlewares
+        @middlewares ||= SidekiqMiddlewareMock.new
+      end
+
+      def self.configure_server
+        yield self
+      end
+
+      def self.server_middleware
+        yield middlewares if block_given?
+        middlewares
+      end
+    end
+
+    before do
+      Appsignal.config = project_fixture_config
+      stub_const "Sidekiq", SidekiqMock
+    end
+
+    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+      described_class.new.install
+
+      expect(Sidekiq.server_middleware.exists?(Appsignal::Hooks::SidekiqPlugin)).to be(true)
+    end
+  end
+end
+
 describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   class DelayedTestClass; end
 
@@ -25,9 +76,10 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     ]
   end
   let(:job_class) { "TestClass" }
+  let(:jid) { "b4a577edbccf1d805744efa9" }
   let(:item) do
     {
-      "jid"         => "b4a577edbccf1d805744efa9",
+      "jid"         => jid,
       "class"       => job_class,
       "retry_count" => 0,
       "queue"       => "default",
@@ -48,37 +100,13 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     expect(log_contents(log)).to_not contains_log(:warn, "Unable to load YAML")
   end
 
-  shared_examples "unknown job action name" do
-    it "sets the action name to unknown" do
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include("action" => "unknown")
-    end
-
-    it "stores no sample data" do
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "sample_data" => {
-          "environment" => {},
-          "params" => [],
-          "tags" => {}
-        }
-      )
-    end
-
-    it "logs a debug message" do
-      expect(log_contents(log)).to contains_log(
-        :debug, "Unable to determine an action name from Sidekiq payload: #{item}"
-      )
-    end
-  end
-
   describe "internal Sidekiq job values" do
     it "does not save internal Sidekiq values as metadata on transaction" do
       perform_job
 
       transaction_hash = transaction.to_h
       expect(transaction_hash["metadata"].keys)
-        .to_not include(*Appsignal::Hooks::SidekiqPlugin::JOB_KEYS)
+        .to_not include(*Appsignal::Hooks::SidekiqPlugin::EXCLUDED_JOB_KEYS)
     end
   end
 
@@ -124,7 +152,7 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   context "when using the Sidekiq delayed extension" do
     let(:item) do
       {
-        "jid" => "efb140489485999d32b5504c",
+        "jid" => jid,
         "class" => "Sidekiq::Extensions::DelayedClass",
         "queue" => "default",
         "args" => [
@@ -164,7 +192,7 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   context "when using the Sidekiq ActiveRecord instance delayed extension" do
     let(:item) do
       {
-        "jid" => "efb140489485999d32b5504c",
+        "jid" => jid,
         "class" => "Sidekiq::Extensions::DelayedModel",
         "queue" => "default",
         "args" => [
@@ -201,217 +229,6 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
     end
   end
 
-  context "when using ActiveJob" do
-    let(:item) do
-      {
-        "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-        "wrapped" => "ActiveJobTestClass",
-        "queue" => "default",
-        "args" => [{
-          "job_class" => "ActiveJobTestJob",
-          "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-          "queue_name" => "default",
-          "arguments" => [
-            "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
-          ]
-        }],
-        "retry" => true,
-        "jid" => "efb140489485999d32b5504c",
-        "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-        "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f
-      }
-    end
-
-    it "creates a transaction with events" do
-      perform_job
-
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include(
-        "id" => kind_of(String),
-        "action" => "ActiveJobTestClass#perform",
-        "error" => nil,
-        "namespace" => namespace,
-        "metadata" => {
-          "queue" => "default"
-        },
-        "sample_data" => {
-          "environment" => {},
-          "params" => [
-            "foo",
-            {
-              "foo" => "Foo",
-              "bar" => "Bar",
-              "baz" => { "1" => "bar" }
-            }
-          ],
-          "tags" => {}
-        }
-      )
-      # TODO: Not available in transaction.to_h yet.
-      # https://github.com/appsignal/appsignal-agent/issues/293
-      expect(transaction.request.env).to eq(
-        :queue_start => Time.parse("2001-01-01 10:00:00UTC").to_f
-      )
-      expect_transaction_to_have_sidekiq_event(transaction_hash)
-    end
-
-    context "with ActionMailer job" do
-      let(:item) do
-        {
-          "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-          "wrapped" => "ActionMailer::DeliveryJob",
-          "queue" => "default",
-          "args" => [{
-            "job_class" => "ActiveMailerTestJob",
-            "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-            "queue_name" => "default",
-            "arguments" => [
-              "MailerClass", "mailer_method", "deliver_now",
-              "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
-            ]
-          }],
-          "retry" => true,
-          "jid" => "efb140489485999d32b5504c",
-          "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-          "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f
-        }
-      end
-
-      it "creates a transaction for the ActionMailer class" do
-        perform_job
-
-        transaction_hash = transaction.to_h
-        expect(transaction_hash).to include(
-          "id" => kind_of(String),
-          "action" => "MailerClass#mailer_method",
-          "error" => nil,
-          "namespace" => namespace,
-          "metadata" => {
-            "queue" => "default"
-          },
-          "sample_data" => {
-            "environment" => {},
-            "params" => [
-              "foo",
-              {
-                "foo" => "Foo",
-                "bar" => "Bar",
-                "baz" => { "1" => "bar" }
-              }
-            ],
-            "tags" => {}
-          }
-        )
-      end
-    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
-        perform_job
-
-        transaction_hash = transaction.to_h
-        expect(transaction_hash["sample_data"]).to include(
-          "params" => [
-            "foo",
-            {
-              "foo" => "[FILTERED]",
-              "bar" => "Bar",
-              "baz" => { "1" => "bar" }
-            }
-          ]
-        )
-      end
-    end
-
-    context "when Sidekiq job payload is missing the 'wrapped' value" do
-      let(:item) do
-        {
-          "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-          "queue" => "default",
-          "args" => [first_argument],
-          "retry" => true,
-          "jid" => "efb140489485999d32b5504c",
-          "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
-          "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f
-        }
-      end
-      before { perform_job }
-
-      context "when the first argument is not a Hash object" do
-        let(:first_argument) { "foo" }
-
-        include_examples "unknown job action name"
-      end
-
-      context "when the first argument is a Hash object not containing a job payload" do
-        let(:first_argument) { { "foo" => "bar" } }
-
-        include_examples "unknown job action name"
-
-        context "when the argument contains an invalid job_class value" do
-          let(:first_argument) { { "job_class" => :foo } }
-
-          include_examples "unknown job action name"
-        end
-      end
-
-      context "when the first argument is a Hash object containing a job payload" do
-        let(:first_argument) do
-          {
-            "job_class" => "ActiveMailerTestJob",
-            "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-            "queue_name" => "default",
-            "arguments" => [
-              "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
-            ]
-          }
-        end
-
-        it "sets the action name to the job class in the first argument" do
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "action" => "ActiveMailerTestJob#perform"
-          )
-        end
-
-        it "stores the job metadata on the transaction" do
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "id" => kind_of(String),
-            "error" => nil,
-            "namespace" => namespace,
-            "metadata" => {
-              "queue" => "default"
-            },
-            "sample_data" => {
-              "environment" => {},
-              "params" => [
-                "foo",
-                {
-                  "foo" => "Foo",
-                  "bar" => "Bar",
-                  "baz" => { "1" => "bar" }
-                }
-              ],
-              "tags" => {}
-            }
-          )
-        end
-
-        it "does not log a debug message" do
-          expect(log_contents(log)).to_not contains_log(
-            :debug, "Unable to determine an action name from Sidekiq payload"
-          )
-        end
-      end
-    end
-  end
-
   context "with an error" do
     let(:error) { ExampleException }
 
@@ -427,7 +244,7 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
 
       transaction_hash = transaction.to_h
       expect(transaction_hash).to include(
-        "id" => kind_of(String),
+        "id" => jid,
         "action" => "TestClass#perform",
         "error" => {
           "name" => "ExampleException",
@@ -461,7 +278,7 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
 
       transaction_hash = transaction.to_h
       expect(transaction_hash).to include(
-        "id" => kind_of(String),
+        "id" => jid,
         "action" => "TestClass#perform",
         "error" => nil,
         "metadata" => {
@@ -510,47 +327,184 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
   end
 end
 
-describe Appsignal::Hooks::SidekiqHook do
-  describe "#dependencies_present?" do
-    subject { described_class.new.dependencies_present? }
+if DependencyHelper.active_job_present?
+  require "active_job"
+  require "action_mailer"
+  require "sidekiq/testing"
+
+  describe "Sidekiq ActiveJob integration" do
+    let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+    let(:time) { Time.parse("2001-01-01 10:00:00UTC") }
+    let(:log) { StringIO.new }
+    let(:given_args) do
+      [
+        "foo",
+        {
+          :foo => "Foo",
+          "bar" => "Bar",
+          "baz" => { "1" => "foo" }
+        }
+      ]
+    end
+    let(:expected_args) do
+      [
+        "foo",
+        {
+          "_aj_symbol_keys" => ["foo"],
+          "foo" => "Foo",
+          "bar" => "Bar",
+          "baz" => {
+            "_aj_symbol_keys" => [],
+            "1" => "foo"
+          }
+        }
+      ]
+    end
+    let(:expected_tags) do
+      {}.tap do |hash|
+        hash["active_job_id"] = kind_of(String)
+        if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
+          hash["provider_job_id"] = kind_of(String)
+        end
+      end
+    end
+    before do
+      start_agent
+      Appsignal.logger = test_logger(log)
+      ActiveJob::Base.queue_adapter = :sidekiq
 
-    context "when Sidekiq constant is found" do
-      before { Object.const_set("Sidekiq", 1) }
-      after { Object.send(:remove_const, "Sidekiq") }
+      class ActiveJobSidekiqTestJob < ActiveJob::Base
+        self.queue_adapter = :sidekiq
 
-      it { is_expected.to be_truthy }
+        def perform(*_args)
+        end
+      end
+
+      class ActiveJobSidekiqErrorTestJob < ActiveJob::Base
+        self.queue_adapter = :sidekiq
+
+        def perform(*_args)
+          raise "uh oh"
+        end
+      end
+      # Manually add the AppSignal middleware for the Testing environment.
+      # It doesn't use configured middlewares by default looks like.
+      # We test somewhere else if the middleware is installed properly.
+      Sidekiq::Testing.server_middleware do |chain|
+        chain.add Appsignal::Hooks::SidekiqPlugin
+      end
+    end
+    around do |example|
+      keep_transactions do
+        Sidekiq::Testing.fake! do
+          example.run
+        end
+      end
+    end
+    after do
+      Object.send(:remove_const, :ActiveJobSidekiqTestJob)
+      Object.send(:remove_const, :ActiveJobSidekiqErrorTestJob)
     end
 
-    context "when Sidekiq constant is not found" do
-      before { Object.send(:remove_const, "Sidekiq") if defined?(Sidekiq) }
+    it "reports the transaction from the ActiveJob integration" do
+      perform_job(ActiveJobSidekiqTestJob, given_args)
 
-      it { is_expected.to be_falsy }
+      transaction = last_transaction
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "ActiveJobSidekiqTestJob#perform",
+        "error" => nil,
+        "namespace" => namespace,
+        "metadata" => hash_including(
+          "queue" => "default"
+        ),
+        "sample_data" => hash_including(
+          "environment" => {},
+          "params" => [expected_args],
+          "tags" => expected_tags.merge("queue" => "default")
+        )
+      )
+      expect(transaction.request.env).to eq(:queue_start => time.to_f)
+      events = transaction_hash["events"]
+        .sort_by { |e| e["start"] }
+        .map { |event| event["name"] }
+      expect(events)
+        .to eq(["perform_job.sidekiq", "perform_start.active_job", "perform.active_job"])
     end
-  end
 
-  describe "#install" do
-    before do
-      Appsignal.config = project_fixture_config
-      module Sidekiq
-        def self.middlewares
-          @middlewares ||= Set.new
-        end
+    context "with error" do
+      it "reports the error on the transaction from the ActiveRecord integration" do
+        expect do
+          perform_job(ActiveJobSidekiqErrorTestJob, given_args)
+        end.to raise_error(RuntimeError, "uh oh")
 
-        def self.configure_server
-          yield self
-        end
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "ActiveJobSidekiqErrorTestJob#perform",
+          "error" => {
+            "name" => "RuntimeError",
+            "message" => "uh oh",
+            "backtrace" => kind_of(String)
+          },
+          "namespace" => namespace,
+          "metadata" => hash_including(
+            "queue" => "default"
+          ),
+          "sample_data" => hash_including(
+            "environment" => {},
+            "params" => [expected_args],
+            "tags" => expected_tags.merge("queue" => "default")
+          )
+        )
+        expect(transaction.request.env).to eq(:queue_start => time.to_f)
+        events = transaction_hash["events"]
+          .sort_by { |e| e["start"] }
+          .map { |event| event["name"] }
+        expect(events)
+          .to eq(["perform_job.sidekiq", "perform_start.active_job", "perform.active_job"])
+      end
+    end
+
+    context "with ActionMailer" do
+      include ActionMailerHelpers
 
-        def self.server_middleware
-          yield middlewares
+      before do
+        class ActionMailerSidekiqTestJob < ActionMailer::Base
+          def welcome(*args)
+          end
         end
       end
+
+      it "reports ActionMailer data on the transaction" do
+        perform_mailer(ActionMailerSidekiqTestJob, :welcome, given_args)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "ActionMailerSidekiqTestJob#welcome",
+          "sample_data" => hash_including(
+            "params" => ["ActionMailerSidekiqTestJob", "welcome", "deliver_now"] + expected_args
+          )
+        )
+      end
     end
-    after { Object.send(:remove_const, "Sidekiq") }
 
-    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
-      described_class.new.install
+    def perform_sidekiq
+      Timecop.freeze(time) do
+        yield
+        # Combined with Sidekiq::Testing.fake! and drain_all we get a
+        # enqueue_at in the job data.
+        Sidekiq::Worker.drain_all
+      end
+    end
+
+    def perform_job(job_class, args)
+      perform_sidekiq { job_class.perform_later(args) }
+    end
 
-      expect(Sidekiq.middlewares).to include(Appsignal::Hooks::SidekiqPlugin)
+    def perform_mailer(mailer, method, args = nil)
+      perform_sidekiq { perform_action_mailer(mailer, method, args) }
     end
   end
 end