appsignal 2.11.0.beta.4-java → 2.11.2-java

data/spec/lib/appsignal/hooks/active_support_notifications/finish_with_state_shared_examples.rb

@@ -0,0 +1,35 @@
+shared_examples "activesupport finish_with_state override" do
+  let(:instrumenter) { as.instrumenter }
+
+  it "instruments an ActiveSupport::Notifications.start/finish event with payload on finish" do
+    listeners_state = instrumenter.start("sql.active_record", {})
+    instrumenter.finish_with_state(listeners_state, "sql.active_record", :sql => "SQL")
+
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "SQL",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "does not instrument events whose name starts with a bang" do
+    expect(Appsignal::Transaction.current).not_to receive(:start_event)
+    expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+    listeners_state = instrumenter.start("!sql.active_record", {})
+    instrumenter.finish_with_state(listeners_state, "!sql.active_record", :sql => "SQL")
+
+    expect(transaction.to_h["events"]).to be_empty
+  end
+end

data/spec/lib/appsignal/hooks/active_support_notifications/instrument_shared_examples.rb

@@ -0,0 +1,145 @@
+shared_examples "activesupport instrument override" do
+  it "instruments an ActiveSupport::Notifications.instrument event" do
+    return_value = as.instrument("sql.active_record", :sql => "SQL") do
+      "value"
+    end
+
+    expect(return_value).to eq "value"
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "SQL",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
+    return_value = as.instrument("no-registered.formatter", :key => "something") do
+      "value"
+    end
+
+    expect(return_value).to eq "value"
+    expect(transaction.to_h["events"]).to match([
+      {
+        "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,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "no-registered.formatter",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "converts non-string names to strings" do
+    as.instrument(:not_a_string) {}
+    expect(transaction.to_h["events"]).to match([
+      {
+        "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,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "not_a_string",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "does not instrument events whose name starts with a bang" do
+    expect(Appsignal::Transaction.current).not_to receive(:start_event)
+    expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+    return_value = as.instrument("!sql.active_record", :sql => "SQL") do
+      "value"
+    end
+
+    expect(return_value).to eq "value"
+  end
+
+  context "when an error is raised in an instrumented block" do
+    it "instruments an ActiveSupport::Notifications.instrument event" do
+      expect do
+        as.instrument("sql.active_record", :sql => "SQL") do
+          raise ExampleException, "foo"
+        end
+      end.to raise_error(ExampleException, "foo")
+
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
+    end
+  end
+
+  context "when a message is thrown in an instrumented block" do
+    it "instruments an ActiveSupport::Notifications.instrument event" do
+      expect do
+        as.instrument("sql.active_record", :sql => "SQL") do
+          throw :foo
+        end
+      end.to throw_symbol(:foo)
+
+      expect(transaction.to_h["events"]).to match([
+        {
+          "allocation_count" => kind_of(Integer),
+          "body" => "SQL",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "child_allocation_count" => kind_of(Integer),
+          "child_duration" => kind_of(Float),
+          "child_gc_duration" => kind_of(Float),
+          "count" => 1,
+          "duration" => kind_of(Float),
+          "gc_duration" => kind_of(Float),
+          "name" => "sql.active_record",
+          "start" => kind_of(Float),
+          "title" => ""
+        }
+      ])
+    end
+  end
+
+  context "when a transaction is completed in an instrumented block" do
+    it "does not complete the ActiveSupport::Notifications.instrument event" do
+      expect(transaction).to receive(:complete)
+      as.instrument("sql.active_record", :sql => "SQL") do
+        Appsignal::Transaction.complete_current!
+      end
+
+      expect(transaction.to_h["events"]).to match([])
+    end
+  end
+end

data/spec/lib/appsignal/hooks/active_support_notifications/start_finish_shared_examples.rb

@@ -0,0 +1,69 @@
+shared_examples "activesupport start finish override" do
+  let(:instrumenter) { as.instrumenter }
+
+  it "instruments an ActiveSupport::Notifications.start/finish event with payload on start ignores payload" do
+    instrumenter.start("sql.active_record", :sql => "SQL")
+    instrumenter.finish("sql.active_record", {})
+
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "instruments an ActiveSupport::Notifications.start/finish event with payload on finish" do
+    instrumenter.start("sql.active_record", {})
+    instrumenter.finish("sql.active_record", :sql => "SQL")
+
+    expect(transaction.to_h["events"]).to match([
+      {
+        "allocation_count" => kind_of(Integer),
+        "body" => "SQL",
+        "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+        "child_allocation_count" => kind_of(Integer),
+        "child_duration" => kind_of(Float),
+        "child_gc_duration" => kind_of(Float),
+        "count" => 1,
+        "duration" => kind_of(Float),
+        "gc_duration" => kind_of(Float),
+        "name" => "sql.active_record",
+        "start" => kind_of(Float),
+        "title" => ""
+      }
+    ])
+  end
+
+  it "does not instrument events whose name starts with a bang" do
+    expect(Appsignal::Transaction.current).not_to receive(:start_event)
+    expect(Appsignal::Transaction.current).not_to receive(:finish_event)
+
+    instrumenter.start("!sql.active_record", {})
+    instrumenter.finish("!sql.active_record", {})
+
+    expect(transaction.to_h["events"]).to be_empty
+  end
+
+  context "when a transaction is completed in an instrumented block" do
+    it "does not complete the ActiveSupport::Notifications.instrument event" do
+      expect(transaction).to receive(:complete)
+
+      instrumenter.start("sql.active_record", {})
+      Appsignal::Transaction.complete_current!
+      instrumenter.finish("sql.active_record", {})
+
+      expect(transaction.to_h["events"]).to match([])
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require_relative "./active_support_notifications/instrument_shared_examples"
+
 describe Appsignal::Hooks::ActiveSupportNotificationsHook do
   if active_support_present?
     let(:notifier) { ActiveSupport::Notifications::Fanout.new }
@@ -18,148 +20,18 @@ describe Appsignal::Hooks::ActiveSupportNotificationsHook do
       it { is_expected.to be_truthy }
     end
 
-    it "instruments an ActiveSupport::Notifications.instrument event" do
-      return_value = as.instrument("sql.active_record", :sql => "SQL") do
-        "value"
-      end
-
-      expect(return_value).to eq "value"
-      expect(transaction.to_h["events"]).to match([
-        {
-          "allocation_count" => kind_of(Integer),
-          "body" => "SQL",
-          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-          "child_allocation_count" => kind_of(Integer),
-          "child_duration" => kind_of(Float),
-          "child_gc_duration" => kind_of(Float),
-          "count" => 1,
-          "duration" => kind_of(Float),
-          "gc_duration" => kind_of(Float),
-          "name" => "sql.active_record",
-          "start" => kind_of(Float),
-          "title" => ""
-        }
-      ])
-    end
-
-    it "instruments an ActiveSupport::Notifications.instrument event with no registered formatter" do
-      return_value = as.instrument("no-registered.formatter", :key => "something") do
-        "value"
-      end
-
-      expect(return_value).to eq "value"
-      expect(transaction.to_h["events"]).to match([
-        {
-          "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,
-          "duration" => kind_of(Float),
-          "gc_duration" => kind_of(Float),
-          "name" => "no-registered.formatter",
-          "start" => kind_of(Float),
-          "title" => ""
-        }
-      ])
-    end
-
-    it "converts non-string names to strings" do
-      as.instrument(:not_a_string) {}
-      expect(transaction.to_h["events"]).to match([
-        {
-          "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,
-          "duration" => kind_of(Float),
-          "gc_duration" => kind_of(Float),
-          "name" => "not_a_string",
-          "start" => kind_of(Float),
-          "title" => ""
-        }
-      ])
-    end
-
-    it "does not instrument events whose name starts with a bang" do
-      expect(Appsignal::Transaction.current).not_to receive(:start_event)
-      expect(Appsignal::Transaction.current).not_to receive(:finish_event)
-
-      return_value = as.instrument("!sql.active_record", :sql => "SQL") do
-        "value"
-      end
-
-      expect(return_value).to eq "value"
-    end
-
-    context "when an error is raised in an instrumented block" do
-      it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect do
-          as.instrument("sql.active_record", :sql => "SQL") do
-            raise ExampleException, "foo"
-          end
-        end.to raise_error(ExampleException, "foo")
-
-        expect(transaction.to_h["events"]).to match([
-          {
-            "allocation_count" => kind_of(Integer),
-            "body" => "SQL",
-            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-            "child_allocation_count" => kind_of(Integer),
-            "child_duration" => kind_of(Float),
-            "child_gc_duration" => kind_of(Float),
-            "count" => 1,
-            "duration" => kind_of(Float),
-            "gc_duration" => kind_of(Float),
-            "name" => "sql.active_record",
-            "start" => kind_of(Float),
-            "title" => ""
-          }
-        ])
-      end
-    end
+    it_behaves_like "activesupport instrument override"
 
-    context "when a message is thrown in an instrumented block" do
-      it "instruments an ActiveSupport::Notifications.instrument event" do
-        expect do
-          as.instrument("sql.active_record", :sql => "SQL") do
-            throw :foo
-          end
-        end.to throw_symbol(:foo)
+    if ::ActiveSupport::Notifications::Instrumenter.method_defined?(:start)
+      require_relative "./active_support_notifications/start_finish_shared_examples"
 
-        expect(transaction.to_h["events"]).to match([
-          {
-            "allocation_count" => kind_of(Integer),
-            "body" => "SQL",
-            "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
-            "child_allocation_count" => kind_of(Integer),
-            "child_duration" => kind_of(Float),
-            "child_gc_duration" => kind_of(Float),
-            "count" => 1,
-            "duration" => kind_of(Float),
-            "gc_duration" => kind_of(Float),
-            "name" => "sql.active_record",
-            "start" => kind_of(Float),
-            "title" => ""
-          }
-        ])
-      end
+      it_behaves_like "activesupport start finish override"
     end
 
-    context "when a transaction is completed in an instrumented block" do
-      it "does not complete the ActiveSupport::Notifications.instrument event" do
-        expect(transaction).to receive(:complete)
-        as.instrument("sql.active_record", :sql => "SQL") do
-          Appsignal::Transaction.complete_current!
-        end
+    if ::ActiveSupport::Notifications::Instrumenter.method_defined?(:finish_with_state)
+      require_relative "./active_support_notifications/finish_with_state_shared_examples"
 
-        expect(transaction.to_h["events"]).to match([])
-      end
+      it_behaves_like "activesupport finish_with_state override"
     end
   else
     describe "#dependencies_present?" do

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

@@ -154,9 +154,11 @@ if DependencyHelper.active_job_present?
         end
 
         it "reports the priority as tag on the transaction" do
-          tags = { :priority => 10, :queue => queue }
+          tags = { :queue => queue }
           expect(Appsignal).to receive(:increment_counter)
             .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_priority_job_count", 1, tags.merge(:priority => 10, :status => :processed))
 
           perform_job(ActiveJobPriorityTestJob)
 
@@ -208,6 +210,47 @@ if DependencyHelper.active_job_present?
           .map { |event| event["name"] }
         expect(events).to eq(["perform_start.active_job", "perform.active_job"])
       end
+
+      if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
+        context "with priority" do
+          before do
+            class ActiveJobErrorPriorityTestJob < ActiveJob::Base
+              queue_with_priority 10
+
+              def perform(*_args)
+                raise "uh oh"
+              end
+            end
+          end
+          after do
+            Object.send(:remove_const, :ActiveJobErrorPriorityTestJob)
+          end
+
+          it "reports the priority as tag on the transaction" do
+            tags = { :queue => queue }
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_job_count", 1, tags.merge(:status => :failed))
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_priority_job_count", 1, tags.merge(:priority => 10, :status => :processed))
+            expect(Appsignal).to receive(:increment_counter)
+              .with("active_job_queue_priority_job_count", 1, tags.merge(:priority => 10, :status => :failed))
+
+            expect do
+              perform_job(ActiveJobErrorPriorityTestJob)
+            end.to raise_error(RuntimeError, "uh oh")
+
+            transaction = last_transaction
+            transaction_hash = transaction.to_h
+            expect(transaction_hash).to include(
+              "sample_data" => hash_including(
+                "tags" => hash_including("queue" => queue, "priority" => 10)
+              )
+            )
+          end
+        end
+      end
     end
 
     context "when wrapped in another transaction" do