appsignal 2.11.0-java → 2.11.4-java

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

@@ -262,7 +262,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 +291,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.

data/spec/lib/appsignal/integrations/object_19_spec.rb

@@ -0,0 +1,266 @@
+require "appsignal/integrations/object"
+
+def is_ruby_19
+  RUBY_VERSION < "2.0"
+end
+
+describe Object do
+  describe "#instrument_method" do
+    context "with instance method" do
+      let(:klass) do
+        Class.new do
+          def foo(param1, options = {})
+            [param1, options]
+          end
+          appsignal_instrument_method :foo
+        end
+      end
+      let(:instance) { klass.new }
+
+      def call_with_arguments
+        instance.foo(
+          "abc",
+          :foo => "bar"
+        )
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once).and_return(transaction)
+        end
+        after { Appsignal.config = nil }
+
+        context "with anonymous class" do
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "foo.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          let(:klass) { NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "foo.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with nested named class" do
+          before do
+            module MyModule
+              module NestedModule
+                class NamedClass
+                  def bar
+                    2
+                  end
+                  appsignal_instrument_method :bar
+                end
+              end
+            end
+          end
+          after { Object.send(:remove_const, :MyModule) }
+          let(:klass) { MyModule::NestedModule::NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "bar.NamedClass.NestedModule.MyModule.other", nil, nil,
+              Appsignal::EventFormatter::DEFAULT
+            expect(instance.bar).to eq(2)
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def foo
+                1
+              end
+              appsignal_instrument_method :foo, :name => "my_method.group"
+            end
+          end
+
+          it "instruments with custom name" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(instance.foo).to eq(1)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def foo
+                yield
+              end
+              appsignal_instrument_method :foo
+            end
+          end
+
+          it "should yield the block" do
+            expect(instance.foo { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "does not instrument, but still calls the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+        end
+      end
+    end
+
+    context "with class method" do
+      let(:klass) do
+        Class.new do
+          def self.bar(param1, options = {})
+            [param1, options]
+          end
+          appsignal_instrument_class_method :bar
+        end
+      end
+      def call_with_arguments
+        klass.bar(
+          "abc",
+          :foo => "bar"
+        )
+      end
+
+      context "when active" do
+        let(:transaction) { http_request_transaction }
+        before do
+          Appsignal.config = project_fixture_config
+          expect(Appsignal::Transaction).to receive(:current).at_least(:once)
+            .and_return(transaction)
+        end
+        after { Appsignal.config = nil }
+
+        context "with anonymous class" do
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "bar.class_method.AnonymousClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+          end
+        end
+
+        context "with named class" do
+          before do
+            class NamedClass
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+          after { Object.send(:remove_const, :NamedClass) }
+          let(:klass) { NamedClass }
+
+          it "instruments the method and calls it" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "bar.class_method.NamedClass.other", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+
+          context "with nested named class" do
+            before do
+              module MyModule
+                module NestedModule
+                  class NamedClass
+                    def self.bar
+                      2
+                    end
+                    appsignal_instrument_class_method :bar
+                  end
+                end
+              end
+            end
+            after { Object.send(:remove_const, :MyModule) }
+            let(:klass) { MyModule::NestedModule::NamedClass }
+
+            it "instruments the method and calls it" do
+              expect(Appsignal.active?).to be_truthy
+              expect(transaction).to receive(:start_event)
+              expect(transaction).to receive(:finish_event).with \
+                "bar.class_method.NamedClass.NestedModule.MyModule.other", nil, nil,
+                Appsignal::EventFormatter::DEFAULT
+              expect(klass.bar).to eq(2)
+            end
+          end
+        end
+
+        context "with custom name" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                2
+              end
+              appsignal_instrument_class_method :bar, :name => "my_method.group"
+            end
+          end
+
+          it "instruments with custom name" do
+            expect(Appsignal.active?).to be_truthy
+            expect(transaction).to receive(:start_event)
+            expect(transaction).to receive(:finish_event).with \
+              "my_method.group", nil, nil, Appsignal::EventFormatter::DEFAULT
+            expect(klass.bar).to eq(2)
+          end
+        end
+
+        context "with a method given a block" do
+          let(:klass) do
+            Class.new do
+              def self.bar
+                yield
+              end
+              appsignal_instrument_class_method :bar
+            end
+          end
+
+          it "should yield the block" do
+            expect(klass.bar { 42 }).to eq(42)
+          end
+        end
+      end
+
+      context "when not active" do
+        let(:transaction) { Appsignal::Transaction.current }
+
+        it "does not instrument, but still call the method" do
+          expect(Appsignal.active?).to be_falsy
+          expect(transaction).to_not receive(:start_event)
+          expect(call_with_arguments).to eq(["abc", { :foo => "bar" }])
+        end
+      end
+    end
+  end
+end