appsignal 2.11.0.alpha.2-java → 2.11.0.beta.1-java

data/lib/appsignal/integrations/que.rb

@@ -32,7 +32,7 @@ module Appsignal
               transaction.set_error(error)
               raise error
             ensure
-              transaction.set_action "#{local_attrs[:job_class]}#run"
+              transaction.set_action_if_nil "#{local_attrs[:job_class]}#run"
               Appsignal::Transaction.complete_current!
             end
           end

data/lib/appsignal/integrations/resque.rb

@@ -4,18 +4,15 @@ module Appsignal
   module Integrations
     # @api private
     module ResquePlugin
-      # Do not use this file as a template for your own background processor
-      # Resque is an exception to the rule and the code below causes the
-      # extension to shut itself down after a single job.
-      # see http://docs.appsignal.com/background-monitoring/custom.html
-      def around_perform_resque_plugin(*_args)
-        Appsignal.monitor_single_transaction(
-          "perform_job.resque",
-          :class => to_s,
-          :method => "perform"
-        ) do
-          yield
-        end
+      def self.extended(_)
+        callers = caller
+        Appsignal::Utils::DeprecationMessage.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" \
+          "#{callers.first}"
       end
     end
   end

data/lib/appsignal/integrations/resque_active_job.rb

@@ -4,38 +4,15 @@ module Appsignal
   module Integrations
     # @api private
     module ResqueActiveJobPlugin
-      include Appsignal::Hooks::Helpers
-
-      def self.included(base)
-        base.class_eval do
-          around_perform do |job, block|
-            params = Appsignal::Utils::HashSanitizer.sanitize(
-              job.arguments,
-              Appsignal.config[:filter_parameters]
-            )
-
-            queue_start =
-              if job.respond_to?(:enqueued_at) && job.enqueued_at
-                Time.parse(job.enqueued_at).utc
-              end
-
-            Appsignal.monitor_single_transaction(
-              "perform_job.resque",
-              :class       => job.class.to_s,
-              :method      => "perform",
-              :params      => params,
-              :queue_start => queue_start,
-              :metadata    => {
-                :id       => job.job_id,
-                :queue    => job.queue_name
-              }
-            ) do
-              block.call
-            end
-          end
-        end
-
-        Appsignal::Environment.report("ruby_active_job_resque_enabled") { true }
+      def self.included(_)
+        callers = caller
+        Appsignal::Utils::DeprecationMessage.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" \
+          "#{callers.first}"
       end
     end
   end

data/lib/appsignal/transaction.rb

@@ -221,6 +221,16 @@ module Appsignal
       set_action_if_nil(group_and_action.compact.join("#"))
     end
 
+    # Set queue start time for transaction.
+    #
+    # Most commononly called by {set_http_or_background_queue_start}.
+    #
+    # @param start [Integer] Queue start time in milliseconds.
+    # @raise [RangeError] When the queue start time value is too big, this
+    #   method raises a RangeError.
+    # @raise [TypeError] Raises a TypeError when the given `start` argument is
+    #   not an Integer.
+    # @return [void]
     def set_queue_start(start)
       return unless start
       @ext.set_queue_start(start)

data/lib/appsignal/utils/deprecation_message.rb

@@ -1,10 +1,14 @@
 module Appsignal
   module Utils
     module DeprecationMessage
-      def deprecation_message(message, logger = Appsignal.logger)
+      def self.message(message, logger = Appsignal.logger)
         $stderr.puts "appsignal WARNING: #{message}"
         logger.warn message
       end
+
+      def deprecation_message(message, logger = Appsignal.logger)
+        Appsignal::Utils::DeprecationMessage.message(message, logger)
+      end
     end
   end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.0.alpha.2".freeze
+  VERSION = "2.11.0.beta.1".freeze
 end

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

@@ -0,0 +1,458 @@
+if DependencyHelper.active_job_present?
+  require "active_job"
+  require "action_mailer"
+
+  describe Appsignal::Hooks::ActiveJobHook do
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      context "when ActiveJob constant is found" do
+        before { stub_const "ActiveJob", Class.new }
+
+        it { is_expected.to be_truthy }
+      end
+
+      context "when ActiveJob constant is not found" do
+        before { hide_const "ActiveJob" }
+
+        it { is_expected.to be_falsy }
+      end
+    end
+
+    describe "#install" do
+      it "extends ActiveJob::Base with the AppSignal ActiveJob plugin" do
+        described_class.new.install
+
+        path, _line_number = ActiveJob::Base.method(:execute).source_location
+        expect(path).to end_with("/lib/appsignal/hooks/active_job.rb")
+      end
+    end
+  end
+
+  describe Appsignal::Hooks::ActiveJobHook::ActiveJobClassInstrumentation do
+    let(:time) { Time.parse("2001-01-01 10:00:00UTC") }
+    let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+    let(:log) { StringIO.new }
+    let(:parameterized_given_args) do
+      {
+        :foo => "Foo",
+        "bar" => "Bar",
+        "baz" => { "1" => "foo" }
+      }
+    end
+    let(:method_given_args) do
+      [
+        "foo",
+        parameterized_given_args
+      ]
+    end
+    let(:parameterized_expected_args) do
+      {
+        "_aj_symbol_keys" => ["foo"],
+        "foo" => "Foo",
+        "bar" => "Bar",
+        "baz" => {
+          "_aj_symbol_keys" => [],
+          "1" => "foo"
+        }
+      }
+    end
+    let(:method_expected_args) do
+      [
+        "foo",
+        parameterized_expected_args
+      ]
+    end
+    before do
+      ActiveJob::Base.queue_adapter = :inline
+
+      start_agent
+      Appsignal.logger = test_logger(log)
+      class ActiveJobTestJob < ActiveJob::Base
+        def perform(*_args)
+        end
+      end
+
+      class ActiveJobErrorTestJob < ActiveJob::Base
+        def perform
+          raise "uh oh"
+        end
+      end
+    end
+    around { |example| keep_transactions { example.run } }
+    after do
+      Object.send(:remove_const, :ActiveJobTestJob)
+      Object.send(:remove_const, :ActiveJobErrorTestJob)
+    end
+
+    it "reports the name from the ActiveJob integration" do
+      perform_job(ActiveJobTestJob)
+
+      transaction = last_transaction
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "ActiveJobTestJob#perform",
+        "error" => nil,
+        "namespace" => namespace,
+        "metadata" => {},
+        "sample_data" => hash_including(
+          "params" => [],
+          "tags" => {
+            "queue" => "default"
+          }
+        )
+      )
+      events = transaction_hash["events"]
+        .sort_by { |e| e["start"] }
+        .map { |event| event["name"] }
+      expect(events).to eq(["perform_start.active_job", "perform.active_job"])
+    end
+
+    context "with error" do
+      it "reports the error on the transaction from the ActiveRecord integration" do
+        expect do
+          perform_job(ActiveJobErrorTestJob)
+        end.to raise_error(RuntimeError, "uh oh")
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "ActiveJobErrorTestJob#perform",
+          "error" => {
+            "name" => "RuntimeError",
+            "message" => "uh oh",
+            "backtrace" => kind_of(String)
+          },
+          "namespace" => namespace,
+          "metadata" => {},
+          "sample_data" => hash_including(
+            "params" => [],
+            "tags" => {
+              "queue" => "default"
+            }
+          )
+        )
+        events = transaction_hash["events"]
+          .sort_by { |e| e["start"] }
+          .map { |event| event["name"] }
+        expect(events).to eq(["perform_start.active_job", "perform.active_job"])
+      end
+    end
+
+    context "when wrapped in another transaction" do
+      it "does not create a new transaction or close the currently open one" do
+        current_transaction = background_job_transaction
+        allow(current_transaction).to receive(:complete).and_call_original
+        set_current_transaction current_transaction
+
+        perform_job(ActiveJobTestJob)
+
+        expect(created_transactions.count).to eql(1)
+        expect(current_transaction).to_not have_received(:complete)
+        current_transaction.complete
+
+        transaction = current_transaction
+        transaction_hash = transaction.to_h
+        # It does set data on the transaction
+        expect(transaction_hash).to include(
+          "id" => current_transaction.transaction_id,
+          "action" => "ActiveJobTestJob#perform",
+          "error" => nil,
+          "namespace" => namespace,
+          "metadata" => {},
+          "sample_data" => hash_including(
+            "params" => [],
+            "tags" => {
+              "queue" => "default"
+            }
+          )
+        )
+        events = transaction_hash["events"]
+          .reject { |e| e["name"] == "enqueue.active_job" }
+          .sort_by { |e| e["start"] }
+          .map { |event| event["name"] }
+        expect(events).to eq(["perform_start.active_job", "perform.active_job"])
+      end
+    end
+
+    context "with params" do
+      it "filters the configured params" do
+        Appsignal.config = project_fixture_config("production")
+        Appsignal.config[:filter_parameters] = ["foo"]
+        perform_job(ActiveJobTestJob, method_given_args)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["sample_data"]["params"]).to include(
+          [
+            "foo",
+            {
+              "_aj_symbol_keys" => ["foo"],
+              "foo" => "[FILTERED]",
+              "bar" => "Bar",
+              "baz" => { "_aj_symbol_keys" => [], "1" => "foo" }
+            }
+          ]
+        )
+      end
+    end
+
+    context "with provider_job_id", :skip => DependencyHelper.rails_version < Gem::Version.new("5.0.0") do
+      before do
+        module ActiveJob
+          module QueueAdapters
+            # Adapter used in our test suite to add provider data to the job
+            # data, as is done by Rails provided ActiveJob adapters.
+            #
+            # This implementation is based on the
+            # `ActiveJob::QueueAdapters::InlineAdapter`.
+            class AppsignalTestAdapter < InlineAdapter
+              def enqueue(job)
+                Base.execute(job.serialize.merge("provider_job_id" => "my_provider_job_id"))
+              end
+            end
+          end
+        end
+
+        class ProviderWrappedActiveJobTestJob < ActiveJob::Base
+          self.queue_adapter = :appsignal_test
+
+          def perform(*_args)
+          end
+        end
+      end
+      after do
+        ActiveJob::QueueAdapters.send(:remove_const, :AppsignalTestAdapter)
+        Object.send(:remove_const, :ProviderWrappedActiveJobTestJob)
+      end
+
+      it "sets provider_job_id as tag" do
+        perform_job(ProviderWrappedActiveJobTestJob)
+
+        transaction = last_transaction
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["sample_data"]["tags"]).to include(
+          "provider_job_id" => "my_provider_job_id"
+        )
+      end
+    end
+
+    context "with enqueued_at", :skip => DependencyHelper.rails_version < Gem::Version.new("6.0.0") do
+      before do
+        module ActiveJob
+          module QueueAdapters
+            # Adapter used in our test suite to add provider data to the job
+            # data, as is done by Rails provided ActiveJob adapters.
+            #
+            # This implementation is based on the
+            # `ActiveJob::QueueAdapters::InlineAdapter`.
+            class AppsignalTestAdapter < InlineAdapter
+              def enqueue(job)
+                Base.execute(job.serialize.merge("enqueued_at" => "2020-10-10T10:10:10Z"))
+              end
+            end
+          end
+        end
+
+        class ProviderWrappedActiveJobTestJob < ActiveJob::Base
+          self.queue_adapter = :appsignal_test
+
+          def perform(*_args)
+          end
+        end
+      end
+      after do
+        ActiveJob::QueueAdapters.send(:remove_const, :AppsignalTestAdapter)
+        Object.send(:remove_const, :ProviderWrappedActiveJobTestJob)
+      end
+
+      it "sets queue time on transaction" do
+        allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
+        perform_job(ProviderWrappedActiveJobTestJob)
+
+        transaction = last_transaction
+        queue_time = Time.parse("2020-10-10T10:10:10Z")
+        expect(transaction).to have_received(:set_queue_start)
+          .with((queue_time.to_f * 1_000).to_i)
+      end
+    end
+
+    context "with ActionMailer job" do
+      include ActionMailerHelpers
+
+      before do
+        class ActionMailerTestJob < ActionMailer::Base
+          def welcome(_first_arg = nil, _second_arg = nil)
+          end
+        end
+      end
+      after do
+        Object.send(:remove_const, :ActionMailerTestJob)
+      end
+
+      context "without params" do
+        it "sets the Action mailer data on the transaction" do
+          perform_mailer(ActionMailerTestJob, :welcome)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "action" => "ActionMailerTestJob#welcome",
+            "sample_data" => hash_including(
+              "params" => ["ActionMailerTestJob", "welcome", "deliver_now"],
+              "tags" => { "queue" => "mailers" }
+            )
+          )
+        end
+      end
+
+      context "with multiple arguments" do
+        it "sets the arguments on the transaction" do
+          perform_mailer(ActionMailerTestJob, :welcome, method_given_args)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "action" => "ActionMailerTestJob#welcome",
+            "sample_data" => hash_including(
+              "params" => ["ActionMailerTestJob", "welcome", "deliver_now"] + method_expected_args,
+              "tags" => { "queue" => "mailers" }
+            )
+          )
+        end
+      end
+
+      if DependencyHelper.rails_version >= Gem::Version.new("5.2.0")
+        context "with parameterized arguments" do
+          it "sets the arguments on the transaction" do
+            perform_mailer(ActionMailerTestJob, :welcome, parameterized_given_args)
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "action" => "ActionMailerTestJob#welcome",
+              "sample_data" => hash_including(
+                "params" => ["ActionMailerTestJob", "welcome", "deliver_now", parameterized_expected_args],
+                "tags" => { "queue" => "mailers" }
+              )
+            )
+          end
+        end
+      end
+    end
+
+    if DependencyHelper.rails_version >= Gem::Version.new("6.0.0")
+      context "with ActionMailer MailDeliveryJob job" do
+        include ActionMailerHelpers
+
+        before do
+          class ActionMailerTestMailDeliveryJob < ActionMailer::Base
+            self.delivery_job = ActionMailer::MailDeliveryJob
+
+            def welcome(*_args)
+            end
+          end
+        end
+        after do
+          Object.send(:remove_const, :ActionMailerTestMailDeliveryJob)
+        end
+
+        it "sets the Action mailer data on the transaction" do
+          perform_mailer(ActionMailerTestMailDeliveryJob, :welcome)
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "action" => "ActionMailerTestMailDeliveryJob#welcome",
+            "sample_data" => hash_including(
+              "params" => [
+                "ActionMailerTestMailDeliveryJob",
+                "welcome",
+                "deliver_now",
+                { active_job_internal_key => ["args"], "args" => [] }
+              ],
+              "tags" => { "queue" => "mailers" }
+            )
+          )
+        end
+
+        context "with method arguments" do
+          it "sets the Action mailer data on the transaction" do
+            perform_mailer(ActionMailerTestMailDeliveryJob, :welcome, method_given_args)
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "action" => "ActionMailerTestMailDeliveryJob#welcome",
+              "sample_data" => hash_including(
+                "params" => [
+                  "ActionMailerTestMailDeliveryJob",
+                  "welcome",
+                  "deliver_now",
+                  {
+                    active_job_internal_key => ["args"],
+                    "args" => method_expected_args
+                  }
+                ],
+                "tags" => { "queue" => "mailers" }
+              )
+            )
+          end
+        end
+
+        context "with parameterized arguments" do
+          it "sets the Action mailer data on the transaction" do
+            perform_mailer(ActionMailerTestMailDeliveryJob, :welcome, parameterized_given_args)
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "action" => "ActionMailerTestMailDeliveryJob#welcome",
+              "sample_data" => hash_including(
+                "params" => [
+                  "ActionMailerTestMailDeliveryJob",
+                  "welcome",
+                  "deliver_now",
+                  {
+                    active_job_internal_key => ["params", "args"],
+                    "args" => [],
+                    "params" => parameterized_expected_args
+                  }
+                ],
+                "tags" => { "queue" => "mailers" }
+              )
+            )
+          end
+        end
+      end
+    end
+
+    def perform_active_job
+      Timecop.freeze(time) do
+        yield
+      end
+    end
+
+    def perform_job(job_class, args = nil)
+      perform_active_job do
+        if args
+          job_class.perform_later(args)
+        else
+          job_class.perform_later
+        end
+      end
+    end
+
+    def perform_mailer(mailer, method, args = nil)
+      perform_active_job { perform_action_mailer(mailer, method, args) }
+    end
+
+    def active_job_internal_key
+      if DependencyHelper.ruby_version >= Gem::Version.new("2.7.0")
+        "_aj_ruby2_keywords"
+      else
+        "_aj_symbol_keys"
+      end
+    end
+  end
+end