appsignal 2.11.1 → 2.11.6

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "2.11.1".freeze
+  VERSION = "2.11.6".freeze
 end

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

@@ -60,7 +60,10 @@ describe Appsignal::Hooks::ResqueHook do
           "error" => nil,
           "namespace" => namespace,
           "metadata" => {},
-          "sample_data" => { "tags" => { "queue" => queue } }
+          "sample_data" => {
+            "breadcrumbs" => [],
+            "tags" => { "queue" => queue }
+          }
         )
         expect(transaction_hash["events"].map { |e| e["name"] })
           .to eql(["perform.resque"])
@@ -84,7 +87,10 @@ describe Appsignal::Hooks::ResqueHook do
             },
             "namespace" => namespace,
             "metadata" => {},
-            "sample_data" => { "tags" => { "queue" => queue } }
+            "sample_data" => {
+              "breadcrumbs" => [],
+              "tags" => { "queue" => queue }
+            }
           )
         end
       end
@@ -118,6 +124,7 @@ describe Appsignal::Hooks::ResqueHook do
             "metadata" => {},
             "sample_data" => {
               "tags" => { "queue" => queue },
+              "breadcrumbs" => [],
               "params" => [
                 "foo",
                 {
@@ -174,6 +181,7 @@ describe Appsignal::Hooks::ResqueHook do
             "namespace" => namespace,
             "metadata" => {},
             "sample_data" => {
+              "breadcrumbs" => [],
               "tags" => { "queue" => queue }
               # Params will be set by the ActiveJob integration
             }

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

@@ -1,55 +1,73 @@
 describe Appsignal::Hooks::ShoryukenMiddleware do
-  let(:current_transaction) { background_job_transaction }
-
   class DemoShoryukenWorker
   end
 
+  let(:time) { "2010-01-01 10:01:00UTC" }
   let(:worker_instance) { DemoShoryukenWorker.new }
-  let(:queue) { double }
-  let(:sqs_msg) { double(:attributes => {}) }
+  let(:queue) { "some-funky-queue-name" }
+  let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
   let(:body) { {} }
-
-  before do
-    allow(Appsignal::Transaction).to receive(:current).and_return(current_transaction)
-    start_agent
+  before(:context) { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def perform_job(&block)
+    block ||= lambda {}
+    Timecop.freeze(Time.parse(time)) do
+      Appsignal::Hooks::ShoryukenMiddleware.new.call(
+        worker_instance,
+        queue,
+        sqs_msg,
+        body,
+        &block
+      )
+    end
   end
 
   context "with a performance call" do
-    let(:queue) { "some-funky-queue-name" }
+    let(:sent_timestamp) { Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 }
     let(:sqs_msg) do
-      double(:attributes => { "SentTimestamp" => Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 })
+      double(:message_id => "msg1", :attributes => { "SentTimestamp" => sent_timestamp })
     end
 
     context "with complex argument" do
-      let(:body) do
-        {
-          :foo => "Foo",
-          :bar => "Bar"
-        }
-      end
-      after do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
-      end
+      let(:body) { { :foo => "Foo", :bar => "Bar" } }
 
       it "wraps the job in a transaction with the correct params" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => {
-            :foo => "Foo",
-            :bar => "Bar"
-          },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
+        allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
+        expect { perform_job }.to change { created_transactions.length }.by(1)
+
+        transaction = last_transaction
+        expect(transaction).to be_completed
+        transaction_hash = transaction.to_h
+        expect(transaction_hash).to include(
+          "action" => "DemoShoryukenWorker#perform",
+          "id" => kind_of(String), # AppSignal generated id
+          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+          "error" => nil
         )
+        expect(transaction_hash["events"].first).to include(
+          "allocation_count" => kind_of(Integer),
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "gc_duration" => kind_of(Float),
+          "start" => kind_of(Float),
+          "duration" => kind_of(Float),
+          "name" => "perform_job.shoryuken",
+          "title" => ""
+        )
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "foo" => "Foo", "bar" => "Bar" },
+          "metadata" => {
+            "message_id" => "msg1",
+            "queue" => queue,
+            "SentTimestamp" => sent_timestamp
+          }
+        )
+        expect(transaction).to have_received(:set_queue_start).with(sent_timestamp)
       end
 
       context "with parameter filtering" do
@@ -57,21 +75,16 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
           Appsignal.config = project_fixture_config("production")
           Appsignal.config[:filter_parameters] = ["foo"]
         end
+        after do
+          Appsignal.config[:filter_parameters] = []
+        end
 
         it "filters selected arguments" do
-          expect(Appsignal).to receive(:monitor_transaction).with(
-            "perform_job.shoryuken",
-            :class => "DemoShoryukenWorker",
-            :method => "perform",
-            :metadata => {
-              :queue => "some-funky-queue-name",
-              "SentTimestamp" => 217_123_200_000
-            },
-            :params => {
-              :foo => "[FILTERED]",
-              :bar => "Bar"
-            },
-            :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
+          perform_job
+
+          transaction_hash = last_transaction.to_h
+          expect(transaction_hash["sample_data"]).to include(
+            "params" => { "foo" => "[FILTERED]", "bar" => "Bar" }
           )
         end
       end
@@ -81,23 +94,12 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       let(:body) { "foo bar" }
 
       it "handles string arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => { :params => body },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
-        )
+        perform_job
 
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "params" => body }
+        )
       end
     end
 
@@ -105,58 +107,103 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       let(:body) { 1 }
 
       it "handles primitive types as arguments" do
-        expect(Appsignal).to receive(:monitor_transaction).with(
-          "perform_job.shoryuken",
-          :class => "DemoShoryukenWorker",
-          :method => "perform",
-          :metadata => {
-            :queue => "some-funky-queue-name",
-            "SentTimestamp" => 217_123_200_000
-          },
-          :params => { :params => body },
-          :queue_start => Time.parse("1976-11-18 0:00:00UTC").utc
-        )
+        perform_job
 
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            # nothing
-          end
-        end
+        transaction_hash = last_transaction.to_h
+        expect(transaction_hash["sample_data"]).to include(
+          "params" => { "params" => body }
+        )
       end
     end
   end
 
   context "with exception" do
-    let(:transaction) do
-      Appsignal::Transaction.new(
-        SecureRandom.uuid,
-        Appsignal::Transaction::BACKGROUND_JOB,
-        Appsignal::Transaction::GenericRequest.new({})
+    it "sets the exception on the transaction" do
+      expect do
+        expect do
+          perform_job { raise ExampleException, "error message" }
+        end.to raise_error(ExampleException)
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to be_completed
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "DemoShoryukenWorker#perform",
+        "id" => kind_of(String), # AppSignal generated id
+        "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+        "error" => {
+          "name" => "ExampleException",
+          "message" => "error message",
+          "backtrace" => kind_of(String)
+        }
       )
     end
+  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)
+  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
-
-    it "sets the exception on the transaction" do
-      expect(transaction).to receive(:set_error).with(ExampleException)
+    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 }
 
-    after do
+    it "creates a transaction for the batch" do
+      allow_any_instance_of(Appsignal::Transaction).to receive(:set_queue_start).and_call_original
       expect do
-        Timecop.freeze(Time.parse("01-01-2001 10:01:00UTC")) do
-          Appsignal::Hooks::ShoryukenMiddleware.new.call(worker_instance, queue, sqs_msg, body) do
-            raise ExampleException
-          end
-        end
-      end.to raise_error(ExampleException)
+        perform_job {}
+      end.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction).to be_completed
+      transaction_hash = transaction.to_h
+      expect(transaction_hash).to include(
+        "action" => "DemoShoryukenWorker#perform",
+        "id" => kind_of(String), # AppSignal generated id
+        "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
+        "error" => nil
+      )
+      expect(transaction_hash["events"].first).to include(
+        "allocation_count" => kind_of(Integer),
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "gc_duration" => kind_of(Float),
+        "start" => kind_of(Float),
+        "duration" => kind_of(Float),
+        "name" => "perform_job.shoryuken",
+        "title" => ""
+      )
+      expect(transaction_hash["sample_data"]).to include(
+        "params" => {
+          "msg2" => "foo bar",
+          "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+        },
+        "metadata" => {
+          "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_received(:set_queue_start).with(sent_timestamp)
     end
   end
 end

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

@@ -16,14 +16,31 @@ describe Appsignal::Hooks::SidekiqHook do
   end
 
   describe "#install" do
-    class SidekiqMiddlewareMock < Set
-      def exists?(middleware)
-        include?(middleware)
+    class SidekiqMiddlewareMockWithPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      unless method_defined? :prepend
+        def prepend(middleware) # For Ruby < 2.5
+          insert(0, middleware)
+        end
       end
     end
+
+    class SidekiqMiddlewareMockWithoutPrepend < Array
+      alias add <<
+      alias exists? include?
+
+      undef_method :prepend if method_defined? :prepend # For Ruby >= 2.5
+    end
+
     module SidekiqMock
+      def self.middleware_mock=(mock)
+        @middlewares = mock.new
+      end
+
       def self.middlewares
-        @middlewares ||= SidekiqMiddlewareMock.new
+        @middlewares
       end
 
       def self.configure_server
@@ -36,15 +53,52 @@ describe Appsignal::Hooks::SidekiqHook do
       end
     end
 
+    def add_middleware(middleware)
+      Sidekiq.configure_server do |sidekiq_config|
+        sidekiq_config.middlewares.add(middleware)
+      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
+    context "when Sidekiq middleware responds to prepend method" do # Sidekiq 3.3.0 and newer
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithPrepend }
+
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain in the first position" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
 
-      expect(Sidekiq.server_middleware.exists?(Appsignal::Hooks::SidekiqPlugin)).to be(true)
+        expect(Sidekiq.server_middleware).to eql([
+          Appsignal::Hooks::SidekiqPlugin, # Prepend makes it the first entry
+          user_middleware1,
+          user_middleware2
+        ])
+      end
+    end
+
+    context "when Sidekiq middleware does not respond to prepend method" do
+      before { Sidekiq.middleware_mock = SidekiqMiddlewareMockWithoutPrepend }
+
+      it "adds the AppSignal SidekiqPlugin to the Sidekiq middleware chain" do
+        user_middleware1 = proc {}
+        add_middleware(user_middleware1)
+        described_class.new.install
+        user_middleware2 = proc {}
+        add_middleware(user_middleware2)
+
+        # Add middlewares in whatever order they were added
+        expect(Sidekiq.server_middleware).to eql([
+          user_middleware1,
+          Appsignal::Hooks::SidekiqPlugin,
+          user_middleware2
+        ])
+      end
     end
   end
 end
@@ -262,7 +316,8 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         "sample_data" => {
           "environment" => {},
           "params" => expected_args,
-          "tags" => {}
+          "tags" => {},
+          "breadcrumbs" => []
         }
       )
       expect_transaction_to_have_sidekiq_event(transaction_hash)
@@ -290,7 +345,8 @@ describe Appsignal::Hooks::SidekiqPlugin, :with_yaml_parse_error => false do
         "sample_data" => {
           "environment" => {},
           "params" => expected_args,
-          "tags" => {}
+          "tags" => {},
+          "breadcrumbs" => []
         }
       )
       # TODO: Not available in transaction.to_h yet.