appsignal 2.4.0 → 2.4.1

data/lib/appsignal/version.rb

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

data/spec/lib/appsignal/cli/diagnose_spec.rb

@@ -155,6 +155,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
         expect(output).to include \
           "Gem version: #{Appsignal::VERSION}",
           "Agent version: #{Appsignal::Extension.agent_version}",
+          "Agent platform: #{Appsignal::System.installed_agent_platform}",
           "Gem install path: #{gem_path}"
       end
 
@@ -164,6 +165,7 @@ describe Appsignal::CLI::Diagnose, :api_stub => true, :report => true do
             "language" => "ruby",
             "package_version" => Appsignal::VERSION,
             "agent_version" => Appsignal::Extension.agent_version,
+            "agent_platform" => Appsignal::System.installed_agent_platform,
             "package_install_path" => gem_path,
             "extension_loaded" => true
           }

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

@@ -0,0 +1,19 @@
+describe Appsignal::Hooks::QueHook do
+  if DependencyHelper.que_present?
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    it "installs the QuePlugin" do
+      expect(Que::Job.included_modules).to include(Appsignal::Integrations::QuePlugin)
+    end
+  else
+    describe "#dependencies_present?" do
+      subject { described_class.new.dependencies_present? }
+
+      it { is_expected.to be_falsy }
+    end
+  end
+end

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

@@ -1,259 +1,419 @@
-describe Appsignal::Hooks::SidekiqPlugin do
-  let(:worker) { double }
-  let(:queue) { double }
-  let(:current_transaction) { background_job_transaction }
-  let(:args) { ["Model", 1] }
+describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
+  class DelayedTestClass; end
+
+  let(:namespace) { Appsignal::Transaction::BACKGROUND_JOB }
+  let(:worker) { anything }
+  let(:queue) { anything }
+  let(:given_args) do
+    [
+      "foo",
+      {
+        :foo => "Foo",
+        :bar => "Bar",
+        "baz" => { 1 => :foo }
+      }
+    ]
+  end
+  let(:expected_args) do
+    [
+      "foo",
+      {
+        "foo" => "Foo",
+        "bar" => "Bar",
+        "baz" => { "1" => "foo" }
+      }
+    ]
+  end
+  let(:job_class) { "TestClass" }
   let(:item) do
     {
-      "class"       => "TestClass",
+      "jid"         => "b4a577edbccf1d805744efa9",
+      "class"       => job_class,
       "retry_count" => 0,
       "queue"       => "default",
-      "enqueued_at" => Time.parse("01-01-2001 10:00:00UTC"),
-      "args"        => args,
+      "created_at"  => Time.parse("2001-01-01 10:00:00UTC").to_f,
+      "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+      "args"        => given_args,
       "extra"       => "data"
     }
   end
   let(:plugin) { Appsignal::Hooks::SidekiqPlugin.new }
-
+  let(:test_store) { {} }
+  let(:log) { StringIO.new }
   before do
-    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
     start_agent
+    Appsignal.logger = test_logger(log)
+
+    # 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)
+
+    # Stub removal of current transaction from current thread so we can fetch
+    # it later.
+    expect(Appsignal::Transaction).to receive(:clear_current_transaction!) do
+      transaction = Thread.current[:appsignal_transaction]
+      test_store[:transaction] = transaction if transaction
+    end
+  end
+  after :with_yaml_parse_error => false do
+    expect(log_contents(log)).to_not contains_log(:warn, "Unable to load YAML")
   end
+  after { clear_current_transaction! }
 
-  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
+  shared_examples "sidekiq metadata" do
+    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)
       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
-      )
+    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" => "foo" }
+            }
+          ]
+        )
+      end
     end
 
-    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
-        }
+    context "with encrypted arguments" do
+      before do
+        item["encrypt"] = true
+        item["args"] << "super secret value" # Last argument will be replaced
       end
-      let(:args) do
+
+      it "replaces the last argument (the secret bag) with an [encrypted data] string" do
+        perform_job
+
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => expected_args << "[encrypted data]"
+        )
+      end
+    end
+
+    context "when using the Sidekiq delayed extension" do
+      let(:item) do
         {
-          :foo => "Foo",
-          :bar => "Bar"
+          "jid" => "efb140489485999d32b5504c",
+          "class" => "Sidekiq::Extensions::DelayedClass",
+          "queue" => "default",
+          "args" => [
+            "---\n- !ruby/class 'DelayedTestClass'\n- :foo_method\n- - :bar: baz\n"
+          ],
+          "retry" => true,
+          "created_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+          "enqueued_at" => Time.parse("2001-01-01 10:00:00UTC").to_f,
+          "extra" => "data"
         }
       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 "uses the delayed class and method name for the action" do
+        perform_job
+
+        transaction_hash = transaction.to_h
+        expect(transaction_hash["action"]).to eq("DelayedTestClass.foo_method")
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => ["bar" => "baz"]
         )
       end
 
-      context "with parameter filtering" do
-        before do
-          Appsignal.config = project_fixture_config("production")
-          Appsignal.config[:filter_parameters] = ["foo"]
-        end
+      context "when job arguments is a malformed YAML object", :with_yaml_parse_error => true do
+        before { item["args"] = [] }
 
-        it "filters selected arguments" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.sidekiq",
-            default_params.merge(
-              :params => {
-                :foo => "[FILTERED]",
-                :bar => "Bar"
-              }
-            )
-          )
+        it "logs a warning and uses the default argument" do
+          perform_job
+
+          transaction_hash = transaction.to_h
+          expect(transaction_hash["action"]).to eq("Sidekiq::Extensions::DelayedClass#perform")
+          expect(transaction_hash["sample_data"]).to include("params" => [])
+          expect(log_contents(log)).to contains_log(:warn, "Unable to load YAML")
         end
       end
     end
 
-    context "when wrapped by ActiveJob" do
+    context "when using ActiveJob" do
       let(:item) do
         {
           "class" => "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper",
-          "wrapped" => "TestClass",
+          "wrapped" => "ActiveJobTestClass",
           "queue" => "default",
           "args" => [{
-            "job_class" => "TestJob",
+            "job_class" => "ActiveJobTestJob",
             "job_id" => "23e79d48-6966-40d0-b2d4-f7938463a263",
             "queue_name" => "default",
-            "arguments" => args
+            "arguments" => [
+              "foo", { "foo" => "Foo", "bar" => "Bar", "baz" => { 1 => :bar } }
+            ]
           }],
           "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
+          "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
-      let(:default_params) do
-        {
-          :class    => "TestClass",
-          :method   => "perform",
-          :metadata => {
+
+      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"
           },
-          :queue_start => Time.parse("01-01-2001 10:00:00UTC").to_f,
-          :queue_time  => 60_000.to_f
-        }
-      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])
+          "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 more complex arguments" do
-        let(:args) do
+      context "with ActionMailer job" do
+        let(:item) do
           {
-            :foo => "Foo",
-            :bar => "Bar"
+            "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 "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 "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
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.sidekiq",
-              default_params.merge(
-                :params => {
-                  :foo => "[FILTERED]",
-                  :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",
+              {
+                "foo" => "[FILTERED]",
+                "bar" => "Bar",
+                "baz" => { "1" => "bar" }
+              }
+            ]
+          )
         end
       end
     end
   end
 
-  context "with an erroring call" do
+  context "with an error" do
     let(:error) { ExampleException }
-    let(:transaction) do
-      Appsignal::Transaction.new(
-        SecureRandom.uuid,
-        Appsignal::Transaction::BACKGROUND_JOB,
-        Appsignal::Transaction::GenericRequest.new({})
-      )
-    end
-    before do
-      allow(Appsignal::Transaction).to receive(:current).and_return(transaction)
-      expect(Appsignal::Transaction).to receive(:create)
-        .with(
-          kind_of(String),
-          Appsignal::Transaction::BACKGROUND_JOB,
-          kind_of(Appsignal::Transaction::GenericRequest)
-        ).and_return(transaction)
-    end
-
-    it "adds the error to the transaction" do
-      expect(transaction).to receive(:set_error).with(error)
-      expect(transaction).to receive(:complete)
-    end
 
-    after do
+    it "creates a transaction and adds the error" 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
-        end
+        perform_job { raise error, "uh oh" }
       end.to raise_error(error)
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "id" => kind_of(String),
+        "action" => "TestClass#perform",
+        "error" => {
+          "name" => "ExampleException",
+          "message" => "uh oh",
+          # TODO: backtrace should be an Array of Strings
+          # https://github.com/appsignal/appsignal-agent/issues/294
+          "backtrace" => kind_of(String)
+        },
+        "metadata" => {
+          "extra" => "data",
+          "queue" => "default",
+          "retry_count" => "0"
+        },
+        "namespace" => namespace,
+        "sample_data" => {
+          "environment" => {},
+          "params" => expected_args,
+          "tags" => {}
+        }
+      )
+      expect_transaction_to_have_sidekiq_event(transaction_hash)
     end
+
+    include_examples "sidekiq metadata"
   end
 
-  # TODO: Don't test (what are basically) private methods
-  describe "#formatted_data" do
-    let(:item) do
-      {
-        "foo"   => "bar",
-        "class" => "TestClass"
-      }
+  context "without an error" do
+    it "creates a transaction with events" do
+      perform_job
+
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "id" => kind_of(String),
+        "action" => "TestClass#perform",
+        "error" => nil,
+        "metadata" => {
+          "extra" => "data",
+          "queue" => "default",
+          "retry_count" => "0"
+        },
+        "namespace" => namespace,
+        "sample_data" => {
+          "environment" => {},
+          "params" => expected_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("2001-01-01 10:00:00UTC").to_f
+      )
+      expect_transaction_to_have_sidekiq_event(transaction_hash)
     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")
+    include_examples "sidekiq metadata"
+  end
+
+  def perform_job
+    Timecop.freeze(Time.parse("2001-01-01 10:01:00UTC")) do
+      plugin.call(worker, item, queue) do
+        yield if block_given?
+      end
     end
   end
+
+  def transaction
+    test_store[:transaction]
+  end
+
+  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
 
 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) }
+  describe "#dependencies_present?" do
+    subject { described_class.new.dependencies_present? }
 
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+    context "when Sidekiq constant is found" do
+      before { Object.const_set("Sidekiq", 1) }
+      after { Object.send(:remove_const, "Sidekiq") }
 
       it { is_expected.to be_truthy }
     end
-  end
 
-  context "without sidekiq" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+    context "when Sidekiq constant is not found" do
+      before { Object.send(:remove_const, "Sidekiq") if defined?(Sidekiq) }
 
       it { is_expected.to be_falsy }
     end
   end
+
+  describe "#install" do
+    before do
+      class Sidekiq
+        def self.middlewares
+          @middlewares ||= Set.new
+        end
+
+        def self.configure_server
+          yield self
+        end
+
+        def self.server_middleware
+          yield middlewares
+        end
+      end
+    end
+    after { Object.send(:remove_const, "Sidekiq") }
+
+    it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+      described_class.new.install
+
+      expect(Sidekiq.middlewares).to include(Appsignal::Hooks::SidekiqPlugin)
+    end
+  end
 end