appsignal 2.11.2-java → 2.11.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3b1274a059f49554109997af44b40585057950b4b8f4d2ab52dd87cc6690ba2
-  data.tar.gz: 42f76f14cf36b7309ade272924f9137e763f0ca56446189d97ea83b8f95a12f6
+  metadata.gz: d7f987568de0465681e378f999401d10053106029050f2e27c66e03634654534
+  data.tar.gz: 9d3bda2c23f46391752218d6a08290e19ffe59a9cdabd3d89841f208a5a4499c
 SHA512:
-  metadata.gz: 23832e2898160147ca20e4881232111628d40864a255642c07f8eea69d3ff89cf6ce8f75cdb63e4c04946f52e383f2ba27eb56ddf812b6c510df567f77c99e5f
-  data.tar.gz: cdbc11ff5c3e7e3b756a8e3ad4dcb1483d7e6772346e652b042e7b3e08e00130d39c2160ea7ef5e47c44f1c8818a678d0393828bf9730f456bab401393754ad0
+  metadata.gz: 626bba54cb4d1e1c5990f7e6636f07fef4b3f211e2bc5943a5bbf8ffa6e0d4eaa78abf5a203b491e32ee4d75fb3a5a6d339aaafa9a0bc12973fce90e0eaa5861
+  data.tar.gz: 62052287406db0bb8e95c6e9130886f9db8f7e9822b9d835a9faec3090facd4990addf13b99f107a26e777a37354bbe8ea795c392917cfe2c0884772000b0b3c

data/.semaphore/semaphore.yml

@@ -31,7 +31,7 @@ global_job_config:
   prologue:
     commands:
     - checkout
-    - git -C /home/semaphore/.rbenv/plugins/ruby-build pull
+    - rm -f $HOME/.rbenv/plugins/rbenv-gem-rehash/etc/rbenv.d/exec/~gem-rehash.bash
     - sem-version ruby $RUBY_VERSION
     - "./support/check_versions"
     - cache restore $_BUNDLER_CACHE-bundler-$RUBY_VERSION-$GEMSET-$(checksum $BUNDLE_GEMFILE)

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+# 2.11.3
+- Support Shoryuken batch workers. PR #687
+
 # 2.11.2
 - Support Ruby 3.0. PR #681
 - Support breadcrumbs. PR #666

data/build_matrix.yml

@@ -32,7 +32,7 @@ semaphore: # Default `.semaphore/semaphore.yml` contents
     prologue:
       commands:
         - checkout
-        - git -C /home/semaphore/.rbenv/plugins/ruby-build pull
+        - rm -f $HOME/.rbenv/plugins/rbenv-gem-rehash/etc/rbenv.d/exec/~gem-rehash.bash
         - sem-version ruby $RUBY_VERSION
         - ./support/check_versions
         - cache restore $_BUNDLER_CACHE-bundler-$RUBY_VERSION-$GEMSET-$(checksum $BUNDLE_GEMFILE)

data/lib/appsignal/hooks/shoryuken.rb

@@ -5,21 +5,60 @@ module Appsignal
     # @api private
     class ShoryukenMiddleware
       def call(worker_instance, queue, sqs_msg, body)
-        metadata = { :queue => queue }.merge(sqs_msg.attributes)
+        batch = sqs_msg.is_a?(Array)
+        attributes =
+          if batch
+            # We can't instrument batched message separately, the `yield` will
+            # perform all the batched messages.
+            # To provide somewhat useful metadata, Get first message based on
+            # SentTimestamp, and use its attributes as metadata for the
+            # transaction. We can't combine them all because then they would
+            # overwrite each other and the last message (in an sorted order)
+            # would be used as the source of the metadata.  With the
+            # oldest/first message at least some useful information is stored
+            # such as the first received time and the number of retries for the
+            # first message. The newer message should have lower values and
+            # timestamps in their metadata.
+            first_msg = sqs_msg.min do |a, b|
+              a.attributes["SentTimestamp"].to_i <=> b.attributes["SentTimestamp"].to_i
+            end
+            # Add batch => true metadata so people can recognize when a
+            # transaction is about a batch of messages.
+            first_msg.attributes.merge(:batch => true)
+          else
+            sqs_msg.attributes.merge(:message_id => sqs_msg.message_id)
+          end
+        metadata = { :queue => queue }.merge(attributes)
         options = {
           :class => worker_instance.class.name,
           :method => "perform",
           :metadata => metadata
         }
 
-        args = body.is_a?(Hash) ? body : { :params => body }
+        args =
+          if batch
+            bodies = {}
+            sqs_msg.each_with_index do |msg, index|
+              # Store all separate bodies on a hash with the key being the
+              # message_id
+              bodies[msg.message_id] = body[index]
+            end
+            bodies
+          else
+            case body
+            when Hash
+              body
+            else
+              { :params => body }
+            end
+          end
         options[:params] = Appsignal::Utils::HashSanitizer.sanitize(
           args,
           Appsignal.config[:filter_parameters]
         )
 
-        if sqs_msg.attributes.key?("SentTimestamp")
-          options[:queue_start] = Time.at(sqs_msg.attributes["SentTimestamp"].to_i / 1000)
+        if attributes.key?("SentTimestamp")
+          options[:queue_start] = Time.at(attributes["SentTimestamp"].to_i / 1000)
         end
 
         Appsignal.monitor_transaction("perform_job.shoryuken", options) do

data/lib/appsignal/version.rb

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 2.11.2
+  version: 2.11.3
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-11 00:00:00.000000000 Z
+date: 2021-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -429,7 +429,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.5
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com