appsignal 3.10.0-java → 3.11.0-java

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

@@ -0,0 +1,459 @@
+describe "Appsignal::Integrations::DelayedJobHook" do
+  before(:context) do
+    module Delayed
+      class Plugin
+        def self.callbacks
+        end
+      end
+
+      class Worker
+        def self.plugins
+          @plugins ||= []
+        end
+      end
+    end
+    require "appsignal/integrations/delayed_job_plugin"
+  end
+  after(:context) { Object.send(:remove_const, :Delayed) }
+  before { start_agent }
+
+  # 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::Integrations::DelayedJobPlugin }
+    let(:time) { Time.parse("01-01-2001 10:01:00UTC") }
+    let(:created_at) { time - 3600 }
+    let(:run_at) { time - 3600 }
+    let(:payload_object) { double(:args => args) }
+    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 => payload_object
+      }
+    end
+    let(:args) { ["argument"] }
+    let(:job) { double(job_data) }
+    let(:invoked_block) { proc {} }
+
+    def perform
+      Timecop.freeze(time) do
+        keep_transactions do
+          plugin.invoke_with_instrumentation(job, invoked_block)
+        end
+      end
+    end
+
+    context "with a normal call" do
+      it "wraps it in a transaction" do
+        perform
+
+        transaction = last_transaction
+        expect(transaction).to have_namespace("background_job")
+        expect(transaction).to have_action("TestClass#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to include_event(:name => "perform_job.delayed_job")
+        expect(transaction).to include_tags(
+          "priority" => 1,
+          "attempts" => 1,
+          "queue" => "default",
+          "id" => "123"
+        )
+        expect(transaction).to include_params(["argument"])
+      end
+
+      context "with more complex params" do
+        let(:args) do
+          {
+            :foo => "Foo",
+            :bar => "Bar"
+          }
+        end
+
+        it "adds the more complex arguments" do
+          perform
+
+          expect(last_transaction).to include_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
+            perform
+
+            expect(last_transaction).to include_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
+          perform
+
+          expect(last_transaction).to have_queue_start(run_at.to_i * 1000)
+        end
+      end
+
+      context "with class method job" do
+        let(:job_data) do
+          { :name => "CustomClassMethod.perform", :payload_object => payload_object }
+        end
+
+        it "wraps it in a transaction using the class method job name" do
+          perform
+          expect(last_transaction).to have_action("CustomClassMethod.perform")
+        end
+      end
+
+      context "with custom name call" do
+        before { perform }
+
+        context "with appsignal_name defined" do
+          context "with payload_object being an object" do
+            context "with value" do
+              let(:payload_object) { double(:appsignal_name => "CustomClass#perform") }
+
+              it "wraps it in a transaction using the custom name" do
+                expect(last_transaction).to have_action("CustomClass#perform")
+              end
+            end
+
+            context "with non-String value" do
+              let(:payload_object) { double(:appsignal_name => Object.new) }
+
+              it "wraps it in a transaction using the original job name" do
+                expect(last_transaction).to have_action("TestClass#perform")
+              end
+            end
+
+            context "with class method name as job" do
+              let(:payload_object) { double(:appsignal_name => "CustomClassMethod.perform") }
+
+              it "wraps it in a transaction using the custom name" do
+                perform
+                expect(last_transaction).to have_action("CustomClassMethod.perform")
+              end
+            end
+          end
+
+          context "with payload_object being a Hash" do
+            context "with value" do
+              let(:payload_object) { double(:appsignal_name => "CustomClassHash#perform") }
+
+              it "wraps it in a transaction using the custom name" do
+                expect(last_transaction).to have_action("CustomClassHash#perform")
+              end
+            end
+
+            context "with non-String value" do
+              let(:payload_object) { double(:appsignal_name => Object.new) }
+
+              it "wraps it in a transaction using the original job name" do
+                expect(last_transaction).to have_action("TestClass#perform")
+              end
+            end
+
+            context "with class method name as job" do
+              let(:payload_object) { { :appsignal_name => "CustomClassMethod.perform" } }
+
+              it "wraps it in a transaction using the custom name" do
+                perform
+                expect(last_transaction).to have_action("CustomClassMethod.perform")
+              end
+            end
+          end
+
+          context "with payload_object acting like a Hash and returning a non-String value" do
+            class ClassActingAsHash
+              def self.[](_key)
+                Object.new
+              end
+
+              def self.appsignal_name
+                "ClassActingAsHash#perform"
+              end
+            end
+            let(:payload_object) { ClassActingAsHash }
+
+            # We check for hash values before object values
+            # this means ClassActingAsHash returns `Object.new` instead
+            # of `self.appsignal_name`. Since this isn't a valid `String`
+            # we return the default job name as action name.
+            it "wraps it in a transaction using the original job name" do
+              expect(last_transaction).to have_action("TestClass#perform")
+            end
+          end
+        end
+      end
+
+      context "with only job class name" do
+        let(:job_data) do
+          { :name => "Banana", :payload_object => payload_object }
+        end
+
+        it "appends #perform to the class name" do
+          perform
+          expect(last_transaction).to have_action("Banana#perform")
+        end
+      end
+
+      if active_job_present?
+        require "active_job"
+
+        context "when wrapped by ActiveJob" do
+          let(:payload_object) 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 => payload_object
+            )
+          end
+          let(:args) { ["activejob_argument"] }
+
+          it "wraps it in a transaction with the correct params" do
+            perform
+
+            transaction = last_transaction
+            expect(transaction).to have_namespace("background_job")
+            expect(transaction).to have_action("TestClass#perform")
+            expect(transaction).to_not have_error
+            expect(transaction).to include_event("name" => "perform_job.delayed_job")
+            expect(transaction).to include_tags(
+              "priority" => 1,
+              "attempts" => 1,
+              "queue" => "default",
+              "id" => "123"
+            )
+            expect(transaction).to include_params(["activejob_argument"])
+          end
+
+          context "with more complex params" do
+            let(:args) do
+              {
+                :foo => "Foo",
+                :bar => "Bar"
+              }
+            end
+
+            it "adds the more complex arguments" do
+              perform
+              transaction = last_transaction
+              expect(transaction).to have_action("TestClass#perform")
+              expect(transaction).to include_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
+                perform
+                transaction = last_transaction
+                expect(transaction).to have_action("TestClass#perform")
+                expect(transaction).to include_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
+              perform
+
+              expect(last_transaction).to have_queue_start(run_at.to_i * 1000)
+            end
+          end
+        end
+      end
+    end
+
+    context "with an erroring call" do
+      let(:error) { ExampleException.new("uh oh") }
+      before do
+        expect(invoked_block).to receive(:call).and_raise(error)
+      end
+
+      it "adds the error to the transaction" do
+        expect do
+          perform
+        end.to raise_error(error)
+
+        transaction = last_transaction
+        expect(transaction).to have_namespace("background_job")
+        expect(transaction).to have_action("TestClass#perform")
+        expect(transaction).to have_error("ExampleException", "uh oh")
+      end
+    end
+  end
+
+  describe ".extract_value" do
+    let(:plugin) { Appsignal::Integrations::DelayedJobPlugin }
+
+    context "for a hash" do
+      let(:hash) { { :key => "value", :bool_false => false } }
+
+      context "when the key exists" do
+        subject { plugin.extract_value(hash, :key) }
+
+        it { is_expected.to eq "value" }
+
+        context "when the value is false" do
+          subject { plugin.extract_value(hash, :bool_false) }
+
+          it { is_expected.to be false }
+        end
+      end
+
+      context "when the key does not exist" do
+        subject { plugin.extract_value(hash, :nonexistent_key) }
+
+        it { is_expected.to be_nil }
+
+        context "with a default value" do
+          subject { plugin.extract_value(hash, :nonexistent_key, 1) }
+
+          it { is_expected.to eq 1 }
+        end
+      end
+    end
+
+    context "for a struct" do
+      before :context do
+        TestStruct = Struct.new(:key)
+      end
+      let(:struct) { TestStruct.new("value") }
+
+      context "when the key exists" do
+        subject { plugin.extract_value(struct, :key) }
+
+        it { is_expected.to eq "value" }
+      end
+
+      context "when the key does not exist" do
+        subject { plugin.extract_value(struct, :nonexistent_key) }
+
+        it { is_expected.to be_nil }
+
+        context "with a default value" do
+          subject { plugin.extract_value(struct, :nonexistent_key, 1) }
+
+          it { is_expected.to eq 1 }
+        end
+      end
+    end
+
+    context "for a struct with a method" do
+      before :context do
+        class TestStructClass < Struct.new(:id) # rubocop:disable Style/StructInheritance
+          def appsignal_name
+            "TestStruct#perform"
+          end
+
+          def bool_false
+            false
+          end
+        end
+      end
+      let(:struct) { TestStructClass.new("id") }
+
+      context "when the Struct responds to a method" do
+        subject { plugin.extract_value(struct, :appsignal_name) }
+
+        it "returns the method value" do
+          is_expected.to eq "TestStruct#perform"
+        end
+
+        context "when the value is false" do
+          subject { plugin.extract_value(struct, :bool_false) }
+
+          it "returns the method value" do
+            is_expected.to be false
+          end
+        end
+      end
+
+      context "when the key does not exist" do
+        subject { plugin.extract_value(struct, :nonexistent_key) }
+
+        context "without a method with the same name" do
+          it "returns nil" do
+            is_expected.to be_nil
+          end
+        end
+
+        context "with a default value" do
+          let(:default_value) { :my_default_value }
+          subject { plugin.extract_value(struct, :nonexistent_key, default_value) }
+
+          it "returns the default value" do
+            is_expected.to eq default_value
+          end
+        end
+      end
+    end
+
+    context "for an object" do
+      let(:object) { double(:existing_method => "value") }
+
+      context "when the method exists" do
+        subject { plugin.extract_value(object, :existing_method) }
+
+        it { is_expected.to eq "value" }
+      end
+
+      context "when the method does not exist" do
+        subject { plugin.extract_value(object, :nonexistent_method) }
+
+        it { is_expected.to be_nil }
+
+        context "and there is a default value" do
+          subject { plugin.extract_value(object, :nonexistent_method, 1) }
+
+          it { is_expected.to eq 1 }
+        end
+      end
+    end
+
+    context "when we need to call to_s on the value" do
+      let(:object) { double(:existing_method => 1) }
+
+      subject { plugin.extract_value(object, :existing_method, nil, true) }
+
+      it { is_expected.to eq "1" }
+    end
+  end
+end

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

@@ -39,7 +39,6 @@ if DependencyHelper.que_present?
         allow(Que).to receive(:execute)
 
         start_agent
-        expect(Appsignal.active?).to be_truthy
       end
       around { |example| keep_transactions { example.run } }
 
@@ -66,7 +65,7 @@ if DependencyHelper.que_present?
             "title" => ""
           )
           expect(transaction).to include_params(%w[1 birds])
-          expect(transaction).to include_sample_metadata(
+          expect(transaction).to include_tags(
             "attempts" => 0,
             "id" => 123,
             "priority" => 100,
@@ -95,7 +94,7 @@ if DependencyHelper.que_present?
           expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
           expect(transaction).to have_error(error.class.name, error.message)
           expect(transaction).to include_params(%w[1 birds])
-          expect(transaction).to include_sample_metadata(
+          expect(transaction).to include_tags(
             "attempts" => 0,
             "id" => 123,
             "priority" => 100,
@@ -120,7 +119,7 @@ if DependencyHelper.que_present?
           expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
           expect(transaction).to have_error(error.class.name, error.message)
           expect(transaction).to include_params(%w[1 birds])
-          expect(transaction).to include_sample_metadata(
+          expect(transaction).to include_tags(
             "attempts" => 0,
             "id" => 123,
             "priority" => 100,

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

@@ -0,0 +1,167 @@
+require "appsignal/integrations/shoryuken"
+
+describe Appsignal::Integrations::ShoryukenMiddleware do
+  class DemoShoryukenWorker
+  end
+
+  let(:time) { "2010-01-01 10:01:00UTC" }
+  let(:worker_instance) { DemoShoryukenWorker.new }
+  let(:queue) { "some-funky-queue-name" }
+  let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
+  let(:body) { {} }
+  before { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def perform_shoryuken_job(&block)
+    block ||= lambda {}
+    Timecop.freeze(Time.parse(time)) do
+      described_class.new.call(
+        worker_instance,
+        queue,
+        sqs_msg,
+        body,
+        &block
+      )
+    end
+  end
+
+  context "with a performance call" do
+    let(:sent_timestamp) { Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 }
+    let(:sqs_msg) do
+      double(:message_id => "msg1", :attributes => { "SentTimestamp" => sent_timestamp })
+    end
+
+    context "with complex argument" do
+      let(:body) { { :foo => "Foo", :bar => "Bar" } }
+
+      it "wraps the job in a transaction with the correct params" do
+        expect { perform_shoryuken_job }.to change { created_transactions.length }.by(1)
+
+        transaction = last_transaction
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+        expect(transaction).to have_action("DemoShoryukenWorker#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to include_event(
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "count" => 1,
+          "name" => "perform_job.shoryuken",
+          "title" => ""
+        )
+        expect(transaction).to include_params("foo" => "Foo", "bar" => "Bar")
+        expect(transaction).to include_tags(
+          "message_id" => "msg1",
+          "queue" => queue,
+          "SentTimestamp" => sent_timestamp
+        )
+        expect(transaction).to have_queue_start(sent_timestamp)
+        expect(transaction).to be_completed
+      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_shoryuken_job
+
+          expect(last_transaction).to include_params("foo" => "[FILTERED]", "bar" => "Bar")
+        end
+      end
+    end
+
+    context "with a string as an argument" do
+      let(:body) { "foo bar" }
+
+      it "handles string arguments" do
+        perform_shoryuken_job
+
+        expect(last_transaction).to include_params("params" => body)
+      end
+    end
+
+    context "with primitive type as argument" do
+      let(:body) { 1 }
+
+      it "handles primitive types as arguments" do
+        perform_shoryuken_job
+
+        expect(last_transaction).to include_params("params" => body)
+      end
+    end
+  end
+
+  context "with exception" do
+    it "sets the exception on the transaction" do
+      expect do
+        expect do
+          perform_shoryuken_job { raise ExampleException, "error message" }
+        end.to raise_error(ExampleException)
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_action("DemoShoryukenWorker#perform")
+      expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+      expect(transaction).to have_error("ExampleException", "error message")
+      expect(transaction).to be_completed
+    end
+  end
+
+  context "with batched jobs" do
+    let(:sqs_msg) do
+      [
+        double(
+          :message_id => "msg2",
+          :attributes => {
+            "SentTimestamp" => (Time.parse("1976-11-18 01:00:00UTC").to_i * 1000).to_s
+          }
+        ),
+        double(
+          :message_id => "msg1",
+          :attributes => { "SentTimestamp" => sent_timestamp.to_s }
+        )
+      ]
+    end
+    let(:body) do
+      [
+        "foo bar",
+        { :id => "123", :foo => "Foo", :bar => "Bar" }
+      ]
+    end
+    let(:sent_timestamp) { Time.parse("1976-11-18 01:00:00UTC").to_i * 1000 }
+
+    it "creates a transaction for the batch" do
+      expect do
+        perform_shoryuken_job {} # rubocop:disable Lint/EmptyBlock
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_action("DemoShoryukenWorker#perform")
+      expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+      expect(transaction).to_not have_error
+      expect(transaction).to include_event(
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "count" => 1,
+        "name" => "perform_job.shoryuken",
+        "title" => ""
+      )
+      expect(transaction).to include_params(
+        "msg2" => "foo bar",
+        "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+      )
+      expect(transaction).to include_tags(
+        "batch" => true,
+        "queue" => "some-funky-queue-name",
+        "SentTimestamp" => sent_timestamp.to_s # Earliest/oldest timestamp from messages
+      )
+      # Queue time based on earliest/oldest timestamp from messages
+      expect(transaction).to have_queue_start(sent_timestamp)
+    end
+  end
+end

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

@@ -362,7 +362,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         perform_sidekiq_job { raise error, "uh oh" }
       end.to raise_error(error)
 
-      expect(transaction).to have_id(jid)
+      expect(transaction).to have_id
       expect(transaction).to have_namespace(namespace)
       expect(transaction).to have_action("TestClass#perform")
       expect(transaction).to have_error("ExampleException", "uh oh")
@@ -373,7 +373,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       )
       expect(transaction).to_not include_environment
       expect(transaction).to include_params(expected_args)
-      expect(transaction).to_not include_tags
+      expect(transaction).to include_tags("request_id" => jid)
       expect(transaction).to_not include_breadcrumbs
       expect_transaction_to_have_sidekiq_event(transaction)
     end
@@ -418,11 +418,11 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :processed })
       perform_sidekiq_job
 
-      expect(transaction).to have_id(jid)
+      expect(transaction).to have_id
       expect(transaction).to have_namespace(namespace)
       expect(transaction).to have_action("TestClass#perform")
       expect(transaction).to_not have_error
-      expect(transaction).to_not include_tags
+      expect(transaction).to include_tags("request_id" => jid)
       expect(transaction).to_not include_environment
       expect(transaction).to_not include_breadcrumbs
       expect(transaction).to_not include_params(expected_args)