appsignal 2.3.6 → 2.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 686ed70481e3668fbca7d42179d37968c9d86ee4
-  data.tar.gz: 0b3e7528800d36741eedf5b245f5f16291ef1cb5
+  metadata.gz: ed63c49d1dfc2fc2760647e86a0721f9a1476d8b
+  data.tar.gz: 5af04584576a18ea0c42e2fb2a2188d0361b826b
 SHA512:
-  metadata.gz: 5594d88adbffbdd61ea850bf13747156fb7cf864585fd70b98a6f910177277cb361b2e31915327d662159def58d761b190990b30307136485aa45c684e22d371
-  data.tar.gz: 894261c72b60a1d21e7c27e2ed7ed2e821211173223e21239118f96d8969ecae8ef9ab563a42e44725e6cde979dc081242f3ea11d0328d8f1e78512f75932d45
+  metadata.gz: 799f054a927e0dd89a7c8775f34b91d271075c25838826589959223be286bbf6ccc8297b0ad97eac00bd1cd6bae52573380ed7b69abd87037ad70ce87552856c
+  data.tar.gz: 719aaed0e8e4e9cc6e398f6ad7a509073e65c19d959b678221e026bc4d15bc478f7fda4541878561bf146c53668c8f8cfc657763a2c54806db2b8214662307af

data/.travis.yml

@@ -30,6 +30,7 @@ gemfile:
   - "gemfiles/resque.gemfile"
   - "gemfiles/sequel.gemfile"
   - "gemfiles/sequel-435.gemfile"
+  - "gemfiles/sidekiq.gemfile"
   - "gemfiles/sinatra.gemfile"
   - "gemfiles/grape.gemfile"
   - "gemfiles/webmachine.gemfile"
@@ -41,6 +42,12 @@ matrix:
       gemfile: "gemfiles/no_dependencies.gemfile"
       script: "bundle exec rubocop"
   exclude:
+    - rvm: "2.0.0"
+      gemfile: "gemfiles/sidekiq.gemfile"
+    - rvm: "2.1.8"
+      gemfile: "gemfiles/sidekiq.gemfile"
+    - rvm: "jruby-19mode"
+      gemfile: "gemfiles/sidekiq.gemfile"
     - rvm: "2.0.0"
       gemfile: "gemfiles/rails-5.0.gemfile"
     - rvm: "2.1.8"

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 2.3.7
+* Support Sidekiq delayed extension job action names better. Now action names
+  are reported as their class and class method name (`MyClass.method`), rather
+  than `Sidekiq::Extensions::DelayedClass#perform` for all jobs through that
+  extension. PR #348
+
 # 2.3.6
 * Allow configuration of permissions of working directory. PR #336
 * Fix locking bug that delayed extension shutdown.
@@ -5,6 +11,10 @@
 * Log extension start with app revision if present
   Commit 51d90bb1207affc2c88f7cff5035a2c36acf9784
 
+# 2.3.5
+
+Yanked
+
 # 2.3.4
 * Fix naming for ActiveJob integration with DelayedJob. PR #345
 

data/Rakefile

@@ -14,6 +14,7 @@ GEMFILES = %w(
   resque
   sequel
   sequel-435
+  sidekiq
   sinatra
   grape
   webmachine

data/gemfiles/sidekiq.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'sidekiq'
+
+gemspec :path => '../'

data/lib/appsignal/hooks/sidekiq.rb

@@ -14,32 +14,78 @@ module Appsignal
       end
 
       def call(_worker, item, _queue)
-        args =
-          if item["class"] == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-            item["args"].first["arguments"]
-          else
-            item["args"]
-          end
-        params = Appsignal::Utils::ParamsSanitizer.sanitize args,
+        job = fetch_sidekiq_job { ::Sidekiq::Job.new(item) }
+        job_metadata = call_and_log_on_error(job, &:item)
+
+        job_action_name = parse_action_name(job)
+        params = Appsignal::Utils::ParamsSanitizer.sanitize(
+          call_and_log_on_error(job, &:display_args),
           :filter_parameters => Appsignal.config[:filter_parameters]
+        )
+
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::BACKGROUND_JOB,
+          Appsignal::Transaction::GenericRequest.new(
+            :queue_start => call_and_log_on_error(job, &:enqueued_at),
+            :queue_time  => call_and_log_on_error(job) { |j| j.latency.to_f * 1000 }
+          )
+        )
+
+        Appsignal.instrument "perform_job.sidekiq" do
+          begin
+            yield
+          rescue Exception => exception # rubocop:disable Lint/RescueException
+            transaction.set_error(exception)
+            raise exception
+          end
+        end
+      ensure
+        if transaction
+          transaction.set_action_if_nil(job_action_name)
+          transaction.params = params
+          formatted_metadata(job_metadata).each do |key, value|
+            transaction.set_metadata key, value
+          end
+          transaction.set_http_or_background_queue_start
+          Appsignal::Transaction.complete_current!
+        end
+      end
+
+      private
+
+      def fetch_sidekiq_job
+        yield
+      rescue NameError => e
+        Appsignal.logger.error("Problem parsing the Sidekiq job data: #{e.inspect}")
+        nil
+      end
+
+      def call_and_log_on_error(job)
+        yield job if job
+      rescue NameError => e
+        Appsignal.logger.error("Problem parsing the Sidekiq job data: #{e.inspect}")
+        nil
+      end
 
-        Appsignal.monitor_transaction(
-          "perform_job.sidekiq",
-          :class       => item["wrapped"] || item["class"],
-          :method      => "perform",
-          :metadata    => formatted_metadata(item),
-          :params      => params,
-          :queue_start => item["enqueued_at"],
-          :queue_time  => (Time.now.to_f - item["enqueued_at"].to_f) * 1000
-        ) do
-          yield
+      def parse_action_name(job)
+        # `job.display_class` needs to be called before `job.display_args`,
+        # see https://github.com/appsignal/appsignal-ruby/pull/348#issuecomment-333629065
+        action_name = call_and_log_on_error(job, &:display_class)
+        if action_name =~ /[\.#]+/
+          action_name
+        else
+          # Add `#perform` as default method name for job names without a
+          # method name
+          "#{action_name}#perform"
         end
       end
 
       def formatted_metadata(item)
-        {}.tap do |hsh|
-          item.each do |key, val|
-            hsh[key] = truncate(string_or_inspect(val)) unless job_keys.include?(key)
+        {}.tap do |hash|
+          (item || {}).each do |key, value|
+            next if job_keys.include?(key)
+            hash[key] = truncate(string_or_inspect(value))
           end
         end
       end
@@ -53,6 +99,7 @@ module Appsignal
       end
 
       def install
+        require "sidekiq/api"
         ::Sidekiq.configure_server do |config|
           config.server_middleware do |chain|
             chain.add Appsignal::Hooks::SidekiqPlugin

data/lib/appsignal/transaction.rb

@@ -54,6 +54,12 @@ module Appsignal
       rescue => e
         Appsignal.logger.error("Failed to complete transaction ##{current.transaction_id}. #{e.message}")
       ensure
+        clear_current_transaction!
+      end
+
+      # Remove current transaction from current Thread.
+      # @api private
+      def clear_current_transaction!
         Thread.current[:appsignal_transaction] = nil
       end
 
@@ -312,6 +318,7 @@ module Appsignal
       finish_event(name, title, body, body_format)
     end
 
+    # @api private
     def to_h
       JSON.parse(@ext.to_json)
     end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 require "yaml"
 
 module Appsignal
-  VERSION = "2.3.6".freeze
+  VERSION = "2.3.7".freeze
 end

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

@@ -1,145 +1,101 @@
-describe Appsignal::Hooks::SidekiqPlugin do
-  let(:worker) { double }
-  let(:queue) { double }
-  let(:current_transaction) { background_job_transaction }
-  let(:args) { ["Model", 1] }
-  let(:item) do
-    {
-      "class"       => "TestClass",
-      "retry_count" => 0,
-      "queue"       => "default",
-      "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC"),
-      "args"        => args,
-      "extra"       => "data"
-    }
-  end
-  let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
+if DependencyHelper.sidekiq_present?
+  describe Appsignal::Hooks::SidekiqPlugin, :with_sidekiq_error => false do
+    let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+    let(:worker) { anything }
+    let(:queue) { anything }
+    let(:args) { ["Model", 1] }
+    let(:job_class) { "TestClass" }
+    let(:item) do
+      {
+        "class"       => job_class,
+        "retry_count" => 0,
+        "queue"       => "default",
+        "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC").to_f,
+        "args"        => args,
+        "extra"       => "data"
+      }
+    end
+    let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
+    let(:test_store) { {} }
 
-  before do
-    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
-    start_agent
-  end
+    before :with_sidekiq_error => false do
+      # Stub calls to extension, because that would remove the transaction
+      # from the extension.
+      allow_any_instance_of(Appsignal::Extension::Transaction).to receive(:finish).and_return(true)
+      allow_any_instance_of(Appsignal::Extension::Transaction).to receive(:complete)
 
-  context "with a performance call" do
-    after do
-      Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-        Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
-          # nothing
-        end
+      # Stub removal of current transaction from current thread so we can fetch
+      # it later.
+      expect(Appsignal::Transaction).to receive(:clear_current_transaction!).at_least(:once) do
+        transaction = Thread.current[:appsignal_transaction]
+        test_store[:transaction] = transaction if transaction
       end
     end
-
-    it "wraps it in a transaction with the correct params" do
-      expect(Appsignal).to receive(:monitor_transaction).with(
-        "perform_job.sidekiq",
-        :class    => "TestClass",
-        :method   => "perform",
-        :metadata => {
-          "retry_count" => "0",
-          "queue"       => "default",
-          "extra"       => "data"
-        },
-        :params      => ["Model", 1],
-        :queue_start => Time.parse("01-01-2001 10:00:00UTC"),
-        :queue_time  => 60_000.to_f
-      )
+    before do
+      start_agent
     end
+    after { clear_current_transaction! }
 
-    context "with more complex arguments" do
-      let(:default_params) do
-        {
-          :class    => "TestClass",
-          :method   => "perform",
-          :metadata => {
-            "retry_count" => "0",
-            "queue"       => "default",
-            "extra"       => "data"
-          },
-          :params => {
-            :foo => "Foo",
-            :bar => "Bar"
-          },
-          :queue_start => Time.parse("01-01-2001 10:00:00UTC"),
-          :queue_time  => 60_000.to_f
-        }
-      end
-      let(:args) do
-        {
-          :foo => "Foo",
-          :bar => "Bar"
-        }
+    context "when there's a problem with calling the Sidekiq::Job class", :with_sidekiq_error => true do
+      let(:log) { StringIO.new }
+      before do
+        Appsignal.logger = Logger.new(log)
+        expect(::Sidekiq::Job).to receive(:new).and_raise(NameError, "woops")
+        perform_job
       end
 
-      it "adds the more complex arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.sidekiq",
-          default_params.merge(
-            :params => {
-              :foo => "Foo",
-              :bar => "Bar"
-            }
-          )
+      it "does not record a transaction and logs an error" do
+        expect(transaction).to be_nil
+        log.rewind
+        expect(log.read).to include(
+          "ERROR",
+          "Problem parsing the Sidekiq job data: #<NameError: woops>"
         )
       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.sidekiq",
-            default_params.merge(
-              :params => {
-                :foo => "[FILTERED]",
-                :bar => "Bar"
-              }
-            )
-          )
-        end
-      end
     end
 
-    context "when wrapped by ActiveJob" do
-      let(:item) do
-        {
-          "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-          "wrapped" => "TestClass",
-          "queue" => "default",
-          "args" => [{
-            "job_class" => "TestJob",
-            "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
-            "queue_name" => "default",
-            "arguments" => args
-          }],
-          "retry" => true,
-          "jid" => "efb140489485999d32b5504c",
-          "created_at" => Time.parse("01-01-2001 10:00:00UTC").to_f,
-          "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC").to_f
-        }
-      end
-      let(:default_params) do
-        {
-          :class    => "TestClass",
-          :method   => "perform",
-          :metadata => {
-            "queue" => "default"
+    context "with a performance call" do
+      it "creates a transaction with performance events" do
+        perform_job
+
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "id" => kind_of(String),
+          "action" => "TestClass#perform",
+          "error" => nil,
+          "namespace" => namespace,
+          "metadata" => {
+            "extra" => "data",
+            "queue" => "default",
+            "retry_count" => "0"
           },
-          :queue_start => Time.parse("01-01-2001 10:00:00UTC").to_f,
-          :queue_time  => 60_000.to_f
-        }
+          "sample_data" => {
+            "environment" => {},
+            "params" => args,
+            "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("01-01-2001 10:00:00UTC"),
+          :queue_time  => 60_000.0
+        )
+        expect_transaction_to_have_sidekiq_event(transaction_hash)
       end
 
-      it "wraps it in a transaction with the correct params" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.sidekiq",
-          default_params.merge(:params => ["Model", 1])
-        )
+      context "when receiving class.method instead of class#method" do
+        let(:job_class) { "ActionMailer.deliver_message" }
+
+        it "uses the class method action name for the action" do
+          perform_job
+
+          transaction_hash = transaction.to_h
+          expect(transaction_hash["action"]).to eq("ActionMailer.deliver_message")
+        end
       end
 
-      context "with more complex arguments" do
+      context "with more complex job arguments" do
         let(:args) do
           {
             :foo => "Foo",
@@ -148,14 +104,14 @@ describe Appsignal::Hooks::SidekiqPlugin do
         end
 
         it "adds the more complex arguments" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.sidekiq",
-            default_params.merge(
-              :params => {
-                :foo => "Foo",
-                :bar => "Bar"
-              }
-            )
+          perform_job
+
+          transaction_hash = transaction.to_h
+          expect(transaction_hash["sample_data"]).to include(
+            "params" => {
+              "foo" => "Foo",
+              "bar" => "Bar"
+            }
           )
         end
 
@@ -166,90 +122,166 @@ describe Appsignal::Hooks::SidekiqPlugin do
           end
 
           it "filters selected arguments" do
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.sidekiq",
-              default_params.merge(
-                :params => {
-                  :foo => "[FILTERED]",
-                  :bar => "Bar"
+            perform_job
+
+            transaction_hash = transaction.to_h
+            expect(transaction_hash["sample_data"]).to include(
+              "params" => {
+                "foo" => "[FILTERED]",
+                "bar" => "Bar"
+              }
+            )
+          end
+        end
+      end
+
+      context "when job is wrapped by ActiveJob" do
+        let(:item) do
+          {
+            "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
+            "wrapped" => "TestClass",
+            "queue" => "default",
+            "args" => [{
+              "job_class" => "TestJob",
+              "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
+              "queue_name" => "default",
+              "arguments" => args
+            }],
+            "retry" => true,
+            "jid" => "efb140489485999d32b5504c",
+            "created_at" => Time.parse("01-01-2001 10:00:00UTC"),
+            "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC").to_f
+          }
+        end
+
+        it "creates a transaction with performance events" do
+          perform_job
+
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "id" => kind_of(String),
+            "action" => "TestClass#perform",
+            "error" => nil,
+            "namespace" => namespace,
+            "metadata" => {
+              "queue" => "default"
+            },
+            "sample_data" => {
+              "environment" => {},
+              "params" => args,
+              "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("01-01-2001 10:00:00UTC"),
+            :queue_time  => 60_000.0
+          )
+          expect_transaction_to_have_sidekiq_event(transaction_hash)
+        end
+
+        context "with more complex arguments" do
+          let(:args) do
+            {
+              :foo => "Foo",
+              :bar => "Bar"
+            }
+          end
+
+          it "adds the more complex arguments" do
+            perform_job
+
+            transaction_hash = transaction.to_h
+            expect(transaction_hash["sample_data"]).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_job
+
+              transaction_hash = transaction.to_h
+              expect(transaction_hash["sample_data"]).to include(
+                "params" => {
+                  "foo" => "[FILTERED]",
+                  "bar" => "Bar"
                 }
               )
-            )
+            end
           end
         end
       end
     end
-  end
 
-  context "with an erroring call" do
-    let(:error) { VerySpecificError }
-    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
+    context "with an erroring job" do
+      let(:error) { VerySpecificError }
+      before do
+        expect do
+          Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
+            plugin.call(worker, item, queue) do
+              raise error, "uh oh"
+            end
+          end
+        end.to raise_error(error)
+      end
 
-    it "adds the error to the transaction" do
-      expect(transaction).to receive(:set_error).with(error)
-      expect(transaction).to receive(:complete)
+      it "adds the error to the transaction" do
+        transaction_hash = transaction.to_h
+        # TODO: backtrace should be an Array of Strings
+        # https://github.com/appsignal/appsignal-agent/issues/294
+        expect(transaction_hash["error"]).to include(
+          "name" => "VerySpecificError",
+          "message" => "uh oh",
+          "backtrace" => kind_of(String)
+        )
+        expect_transaction_to_have_sidekiq_event(transaction_hash)
+      end
     end
 
-    after do
-      expect do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::SidekiqPlugin.new.call(worker, item, queue) do
-            raise error
-          end
+    def perform_job
+      Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
+        plugin.call(worker, item, queue) do
+          # nothing
         end
-      end.to raise_error(error)
+      end
     end
-  end
 
-  # TODO: Don't test (what are basically) private methods
-  describe "#formatted_data" do
-    let(:item) do
-      {
-        "foo"   => "bar",
-        "class" => "TestClass"
-      }
+    def transaction
+      test_store[:transaction]
     end
 
-    it "only adds items to the hash that do not appear in JOB_KEYS" do
-      expect(plugin.formatted_metadata(item)).to eq("foo" => "bar")
+    def expect_transaction_to_have_sidekiq_event(transaction_hash)
+      events = transaction_hash["events"]
+      expect(events.count).to eq(1)
+      expect(events.first).to include(
+        "name"        => "perform_job.sidekiq",
+        "title"       => "",
+        "count"       => 1,
+        "body"        => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT
+      )
     end
   end
 end
 
 describe Appsignal::Hooks::SidekiqHook do
-  context "with sidekiq" do
-    before :context do
-      module Sidekiq
-        def self.configure_server
-        end
-      end
-      Appsignal::Hooks::SidekiqHook.new.install
-    end
-    after(:context) { Object.send(:remove_const, :Sidekiq) }
-
+  if DependencyHelper.sidekiq_present?
     describe "#dependencies_present?" do
       subject { described_class.new.dependencies_present? }
 
       it { is_expected.to be_truthy }
     end
-  end
-
-  context "without sidekiq" do
+  else
     describe "#dependencies_present?" do
       subject { described_class.new.dependencies_present? }
 

data/spec/support/helpers/dependency_helper.rb

@@ -63,6 +63,10 @@ module DependencyHelper
       Gem.loaded_specs["capistrano"].version >= Gem::Version.new("3.0")
   end
 
+  def sidekiq_present?
+    dependency_present? "sidekiq"
+  end
+
   def dependency_present?(dependency_file)
     Gem.loaded_specs.key? dependency_file
   end

data/spec/support/helpers/transaction_helpers.rb

@@ -28,4 +28,10 @@ module TransactionHelpers
       }.merge(args))
     )
   end
+
+  # Use when {Appsignal::Transaction.clear_current_transaction!} is stubbed to
+  # clear the current transaction on the current thread.
+  def clear_current_transaction!
+    Thread.current[:appsignal_transaction] = nil
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.3.6
+  version: 2.3.7
 platform: ruby
 authors:
 - Robert Beekman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-26 00:00:00.000000000 Z
+date: 2017-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -163,6 +163,7 @@ files:
 - gemfiles/resque.gemfile
 - gemfiles/sequel-435.gemfile
 - gemfiles/sequel.gemfile
+- gemfiles/sidekiq.gemfile
 - gemfiles/sinatra.gemfile
 - gemfiles/webmachine.gemfile
 - lib/appsignal.rb
@@ -352,7 +353,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com