appsignal 3.9.2-java → 3.10.0-java

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

@@ -64,23 +64,18 @@ describe Appsignal::Hooks::DelayedJobHook do
       context "with a normal call" do
         it "wraps it in a transaction" do
           perform
-          transaction_data = last_transaction.to_h
-          expect(transaction_data).to include(
-            "action" => "TestClass#perform",
-            "namespace" => "background_job",
-            "error" => nil
-          )
-          expect(transaction_data["events"].map { |e| e["name"] })
-            .to eql(["perform_job.delayed_job"])
-          expect(transaction_data["sample_data"]).to include(
-            "metadata" => {
-              "priority" => 1,
-              "attempts" => 1,
-              "queue" => "default",
-              "id" => "123"
-            },
-            "params" => ["argument"]
+          transaction = last_transaction
+          expect(transaction).to have_action("TestClass#perform")
+          expect(transaction).to have_namespace("background_job")
+          expect(transaction).to_not have_error
+          expect(transaction).to include_event(:name => "perform_job.delayed_job")
+          expect(transaction).to include_sample_metadata(
+            "priority" => 1,
+            "attempts" => 1,
+            "queue" => "default",
+            "id" => "123"
           )
+          expect(transaction).to include_params(["argument"])
         end
 
         context "with more complex params" do
@@ -93,13 +88,8 @@ describe Appsignal::Hooks::DelayedJobHook do
 
           it "adds the more complex arguments" do
             perform
-            transaction_data = last_transaction.to_h
-            expect(transaction_data["sample_data"]).to include(
-              "params" => {
-                "foo" => "Foo",
-                "bar" => "Bar"
-              }
-            )
+
+            expect(last_transaction).to include_params("foo" => "Foo", "bar" => "Bar")
           end
 
           context "with parameter filtering" do
@@ -110,13 +100,8 @@ describe Appsignal::Hooks::DelayedJobHook do
 
             it "filters selected arguments" do
               perform
-              transaction_data = last_transaction.to_h
-              expect(transaction_data["sample_data"]).to include(
-                "params" => {
-                  "foo" => "[FILTERED]",
-                  "bar" => "Bar"
-                }
-              )
+
+              expect(last_transaction).to include_params("foo" => "[FILTERED]", "bar" => "Bar")
             end
           end
         end
@@ -125,13 +110,9 @@ describe Appsignal::Hooks::DelayedJobHook do
           let(:run_at) { Time.parse("2017-01-01 10:01:00UTC") }
 
           it "reports queue_start with run_at time" do
-            # TODO: Not available in transaction.to_h yet.
-            # https://github.com/appsignal/appsignal-agent/issues/293
-            expect(Appsignal).to receive(:monitor_transaction).with(
-              "perform_job.delayed_job",
-              a_hash_including(:queue_start => run_at)
-            ).and_call_original
             perform
+
+            expect(last_transaction).to have_queue_start(run_at.to_i * 1000)
           end
         end
 
@@ -142,7 +123,7 @@ describe Appsignal::Hooks::DelayedJobHook do
 
           it "wraps it in a transaction using the class method job name" do
             perform
-            expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+            expect(last_transaction).to have_action("CustomClassMethod.perform")
           end
         end
 
@@ -155,7 +136,7 @@ describe Appsignal::Hooks::DelayedJobHook do
                 let(:payload_object) { double(:appsignal_name => "CustomClass#perform") }
 
                 it "wraps it in a transaction using the custom name" do
-                  expect(last_transaction.to_h["action"]).to eql("CustomClass#perform")
+                  expect(last_transaction).to have_action("CustomClass#perform")
                 end
               end
 
@@ -163,7 +144,7 @@ describe Appsignal::Hooks::DelayedJobHook do
                 let(:payload_object) { double(:appsignal_name => Object.new) }
 
                 it "wraps it in a transaction using the original job name" do
-                  expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                  expect(last_transaction).to have_action("TestClass#perform")
                 end
               end
 
@@ -172,7 +153,7 @@ describe Appsignal::Hooks::DelayedJobHook do
 
                 it "wraps it in a transaction using the custom name" do
                   perform
-                  expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+                  expect(last_transaction).to have_action("CustomClassMethod.perform")
                 end
               end
             end
@@ -182,7 +163,7 @@ describe Appsignal::Hooks::DelayedJobHook do
                 let(:payload_object) { double(:appsignal_name => "CustomClassHash#perform") }
 
                 it "wraps it in a transaction using the custom name" do
-                  expect(last_transaction.to_h["action"]).to eql("CustomClassHash#perform")
+                  expect(last_transaction).to have_action("CustomClassHash#perform")
                 end
               end
 
@@ -190,7 +171,7 @@ describe Appsignal::Hooks::DelayedJobHook do
                 let(:payload_object) { double(:appsignal_name => Object.new) }
 
                 it "wraps it in a transaction using the original job name" do
-                  expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                  expect(last_transaction).to have_action("TestClass#perform")
                 end
               end
 
@@ -199,7 +180,7 @@ describe Appsignal::Hooks::DelayedJobHook do
 
                 it "wraps it in a transaction using the custom name" do
                   perform
-                  expect(last_transaction.to_h["action"]).to eql("CustomClassMethod.perform")
+                  expect(last_transaction).to have_action("CustomClassMethod.perform")
                 end
               end
             end
@@ -221,7 +202,7 @@ describe Appsignal::Hooks::DelayedJobHook do
               # of `self.appsignal_name`. Since this isn't a valid `String`
               # we return the default job name as action name.
               it "wraps it in a transaction using the original job name" do
-                expect(last_transaction.to_h["action"]).to eql("TestClass#perform")
+                expect(last_transaction).to have_action("TestClass#perform")
               end
             end
           end
@@ -234,7 +215,7 @@ describe Appsignal::Hooks::DelayedJobHook do
 
           it "appends #perform to the class name" do
             perform
-            expect(last_transaction.to_h["action"]).to eql("Banana#perform")
+            expect(last_transaction).to have_action("Banana#perform")
           end
         end
 
@@ -267,23 +248,19 @@ describe Appsignal::Hooks::DelayedJobHook do
 
             it "wraps it in a transaction with the correct params" do
               perform
-              transaction_data = last_transaction.to_h
-              expect(transaction_data).to include(
-                "action" => "TestClass#perform",
-                "namespace" => "background_job",
-                "error" => nil
-              )
-              expect(transaction_data["events"].map { |e| e["name"] })
-                .to eql(["perform_job.delayed_job"])
-              expect(transaction_data["sample_data"]).to include(
-                "metadata" => {
-                  "priority" => 1,
-                  "attempts" => 1,
-                  "queue" => "default",
-                  "id" => "123"
-                },
-                "params" => ["activejob_argument"]
+
+              transaction = last_transaction
+              expect(transaction).to have_namespace("background_job")
+              expect(transaction).to have_action("TestClass#perform")
+              expect(transaction).to_not have_error
+              expect(transaction).to include_event("name" => "perform_job.delayed_job")
+              expect(transaction).to include_sample_metadata(
+                "priority" => 1,
+                "attempts" => 1,
+                "queue" => "default",
+                "id" => "123"
               )
+              expect(transaction).to include_params(["activejob_argument"])
             end
 
             context "with more complex params" do
@@ -296,13 +273,11 @@ describe Appsignal::Hooks::DelayedJobHook do
 
               it "adds the more complex arguments" do
                 perform
-                transaction_data = last_transaction.to_h
-                expect(transaction_data).to include("action" => "TestClass#perform")
-                expect(transaction_data["sample_data"]).to include(
-                  "params" => {
-                    "foo" => "Foo",
-                    "bar" => "Bar"
-                  }
+                transaction = last_transaction
+                expect(transaction).to have_action("TestClass#perform")
+                expect(transaction).to include_params(
+                  "foo" => "Foo",
+                  "bar" => "Bar"
                 )
               end
 
@@ -314,13 +289,11 @@ describe Appsignal::Hooks::DelayedJobHook do
 
                 it "filters selected arguments" do
                   perform
-                  transaction_data = last_transaction.to_h
-                  expect(transaction_data).to include("action" => "TestClass#perform")
-                  expect(transaction_data["sample_data"]).to include(
-                    "params" => {
-                      "foo" => "[FILTERED]",
-                      "bar" => "Bar"
-                    }
+                  transaction = last_transaction
+                  expect(transaction).to have_action("TestClass#perform")
+                  expect(transaction).to include_params(
+                    "foo" => "[FILTERED]",
+                    "bar" => "Bar"
                   )
                 end
               end
@@ -330,11 +303,9 @@ describe Appsignal::Hooks::DelayedJobHook do
               let(:run_at) { Time.parse("2017-01-01 10:01:00UTC") }
 
               it "reports queue_start with run_at time" do
-                expect(Appsignal).to receive(:monitor_transaction).with(
-                  "perform_job.delayed_job",
-                  a_hash_including(:queue_start => run_at)
-                ).and_call_original
                 perform
+
+                expect(last_transaction).to have_queue_start(run_at.to_i * 1000)
               end
             end
           end
@@ -352,18 +323,10 @@ describe Appsignal::Hooks::DelayedJobHook do
             perform
           end.to raise_error(error)
 
-          transaction_data = last_transaction.to_h
-          expect(transaction_data).to include(
-            "action" => "TestClass#perform",
-            "namespace" => "background_job",
-            "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)
-            }
-          )
+          transaction = last_transaction
+          expect(transaction).to have_namespace("background_job")
+          expect(transaction).to have_action("TestClass#perform")
+          expect(transaction).to have_error("ExampleException", "uh oh")
         end
       end
     end

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

@@ -53,22 +53,13 @@ if DependencyHelper.dry_monitor_present?
 
       it "creates an sql event" do
         notifications.instrument(event_id, payload)
-        expect(transaction.to_h["events"]).to match([
-          {
-            "allocation_count" => kind_of(Integer),
-            "body" => "SELECT * FROM users",
-            "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" => "query.postgres",
-            "start" => kind_of(Float),
-            "title" => "query.postgres"
-          }
-        ])
+        expect(transaction).to include_event(
+          "body" => "SELECT * FROM users",
+          "body_format" => Appsignal::EventFormatter::SQL_BODY_FORMAT,
+          "count" => 1,
+          "name" => "query.postgres",
+          "title" => "query.postgres"
+        )
       end
     end
 
@@ -82,22 +73,13 @@ if DependencyHelper.dry_monitor_present?
 
       it "creates a generic event" do
         notifications.instrument(event_id, payload)
-        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" => "foo",
-            "start" => kind_of(Float),
-            "title" => ""
-          }
-        ])
+        expect(transaction).to include_event(
+          "body" => "",
+          "body_format" => Appsignal::EventFormatter::DEFAULT,
+          "count" => 1,
+          "name" => "foo",
+          "title" => ""
+        )
       end
     end
   end

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

@@ -40,12 +40,10 @@ describe Appsignal::Hooks::ExconHook do
         }
         Excon.defaults[:instrumentor].instrument("excon.request", data) {} # rubocop:disable Lint/EmptyBlock
 
-        expect(transaction.to_h["events"]).to include(
-          hash_including(
-            "name" => "request.excon",
-            "title" => "GET http://www.google.com",
-            "body" => ""
-          )
+        expect(transaction).to include_event(
+          "name" => "request.excon",
+          "title" => "GET http://www.google.com",
+          "body" => ""
         )
       end
 
@@ -53,12 +51,10 @@ describe Appsignal::Hooks::ExconHook do
         data = { :host => "www.google.com" }
         Excon.defaults[:instrumentor].instrument("excon.response", data) {} # rubocop:disable Lint/EmptyBlock
 
-        expect(transaction.to_h["events"]).to include(
-          hash_including(
-            "name" => "response.excon",
-            "title" => "www.google.com",
-            "body" => ""
-          )
+        expect(transaction).to include_event(
+          "name" => "response.excon",
+          "title" => "www.google.com",
+          "body" => ""
         )
       end
     end

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

@@ -1,51 +1,16 @@
 describe Appsignal::Hooks::NetHttpHook do
-  before :context do
-    start_agent
-  end
+  before(:context) { start_agent }
 
-  context "with Net::HTTP instrumentation enabled" do
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+  describe "#dependencies_present?" do
+    subject { described_class.new.dependencies_present? }
 
+    context "with Net::HTTP instrumentation enabled" do
       it { is_expected.to be_truthy }
     end
 
-    it "should instrument a http request" do
-      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("request.net_http", "GET http://www.google.com", nil, 0)
-
-      stub_request(:any, "http://www.google.com/")
-
-      Net::HTTP.get_response(URI.parse("http://www.google.com"))
-    end
-
-    it "should instrument a https request" do
-      Appsignal::Transaction.create("uuid", Appsignal::Transaction::HTTP_REQUEST, "test")
-      expect(Appsignal::Transaction.current).to receive(:start_event)
-        .at_least(:once)
-      expect(Appsignal::Transaction.current).to receive(:finish_event)
-        .at_least(:once)
-        .with("request.net_http", "GET https://www.google.com", nil, 0)
-
-      stub_request(:any, "https://www.google.com/")
-
-      uri = URI.parse("https://www.google.com")
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.get(uri.request_uri)
-    end
-  end
-
-  context "with Net::HTTP instrumentation disabled" do
-    before { Appsignal.config.config_hash[:instrument_net_http] = false }
-    after { Appsignal.config.config_hash[:instrument_net_http] = true }
-
-    describe "#dependencies_present?" do
-      subject { described_class.new.dependencies_present? }
+    context "with Net::HTTP instrumentation disabled" do
+      before { Appsignal.config.config_hash[:instrument_net_http] = false }
+      after { Appsignal.config.config_hash[:instrument_net_http] = true }
 
       it { is_expected.to be_falsy }
     end

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

@@ -1,61 +1,106 @@
 require "rake"
 
 describe Appsignal::Hooks::RakeHook do
+  let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
   let(:task) { Rake::Task.new("task:name", Rake::Application.new) }
   let(:arguments) { Rake::TaskArguments.new(["foo"], ["bar"]) }
-  let(:generic_request) { Appsignal::Transaction::GenericRequest.new({}) }
-  before(:context) { start_agent }
+  before do
+    start_agent
+    allow(Kernel).to receive(:at_exit)
+  end
+  around { |example| keep_transactions { example.run } }
+  after do
+    if helper.instance_variable_defined?(:@register_at_exit_hook)
+      helper.remove_instance_variable(:@register_at_exit_hook)
+    end
+  end
+
+  def expect_to_not_have_registered_at_exit_hook
+    expect(Kernel).to_not have_received(:at_exit)
+  end
+
+  def expect_to_have_registered_at_exit_hook
+    expect(Kernel).to have_received(:at_exit)
+  end
 
   describe "#execute" do
     context "without error" do
-      before { expect(Appsignal).to_not receive(:stop) }
-
       def perform
         task.execute(arguments)
       end
 
-      it "creates no transaction" do
-        expect(Appsignal::Transaction).to_not receive(:new)
-        expect { perform }.to_not(change { created_transactions })
+      context "with :enable_rake_performance_instrumentation == false" do
+        before do
+          Appsignal.config[:enable_rake_performance_instrumentation] = false
+        end
+
+        it "creates no transaction" do
+          expect { perform }.to_not(change { created_transactions.count })
+        end
+
+        it "calls the original task" do
+          expect(perform).to eq([])
+        end
+
+        it "does not register an at_exit hook" do
+          perform
+          expect_to_not_have_registered_at_exit_hook
+        end
       end
 
-      it "calls the original task" do
-        expect(perform).to eq([])
+      context "with :enable_rake_performance_instrumentation == true" do
+        before do
+          Appsignal.config[:enable_rake_performance_instrumentation] = true
+        end
+
+        it "creates a transaction" do
+          expect { perform }.to(change { created_transactions.count }.by(1))
+
+          transaction = last_transaction
+          expect(transaction).to have_id
+          expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+          expect(transaction).to have_action("task:name")
+          expect(transaction).to_not have_error
+          expect(transaction).to include_params("foo" => "bar")
+          expect(transaction).to include_event("name" => "task.rake")
+          expect(transaction).to be_completed
+        end
+
+        it "calls the original task" do
+          expect(perform).to eq([])
+        end
+
+        it "registers an at_exit hook" do
+          perform
+          expect_to_have_registered_at_exit_hook
+        end
       end
     end
 
     context "with error" do
-      let(:error) { ExampleException }
       before do
-        task.enhance { raise error, "my error message" }
-        # We don't call `and_call_original` here as we don't want AppSignal to
-        # stop and start for every spec.
-        expect(Appsignal).to receive(:stop).with("rake")
+        task.enhance { raise ExampleException, "error message" }
       end
 
       def perform
-        keep_transactions do
-          expect { task.execute(arguments) }.to raise_error(error)
-        end
+        expect { task.execute(arguments) }.to raise_error(ExampleException, "error message")
       end
 
       it "creates a background job transaction" do
         perform
 
-        expect(last_transaction).to be_completed
-        expect(last_transaction.to_h).to include(
-          "id" => kind_of(String),
-          "namespace" => Appsignal::Transaction::BACKGROUND_JOB,
-          "action" => "task:name",
-          "error" => {
-            "name" => "ExampleException",
-            "message" => "my error message",
-            "backtrace" => kind_of(String)
-          },
-          "sample_data" => hash_including(
-            "params" => { "foo" => "bar" }
-          )
-        )
+        transaction = last_transaction
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+        expect(transaction).to have_action("task:name")
+        expect(transaction).to have_error("ExampleException", "error message")
+        expect(transaction).to include_params("foo" => "bar")
+        expect(transaction).to be_completed
+      end
+
+      it "registers an at_exit hook" do
+        perform
+        expect_to_have_registered_at_exit_hook
       end
 
       context "when first argument is not a `Rake::TaskArguments`" do
@@ -64,11 +109,39 @@ describe Appsignal::Hooks::RakeHook do
         it "does not add the params to the transaction" do
           perform
 
-          expect(last_transaction.to_h).to include(
-            "sample_data" => hash_excluding("params")
-          )
+          expect(last_transaction).to_not include_params
         end
       end
     end
   end
 end
+
+describe "Appsignal::Integrations::RakeIntegrationHelper" do
+  let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
+  describe ".register_at_exit_hook" do
+    before do
+      start_agent
+      allow(Appsignal).to receive(:stop)
+    end
+
+    it "registers the at_exit hook only once" do
+      allow(Kernel).to receive(:at_exit)
+      helper.register_at_exit_hook
+      helper.register_at_exit_hook
+      expect(Kernel).to have_received(:at_exit).once
+    end
+  end
+
+  describe ".at_exit_hook" do
+    let(:helper) { Appsignal::Integrations::RakeIntegrationHelper }
+    before do
+      start_agent
+      allow(Appsignal).to receive(:stop)
+    end
+
+    it "calls Appsignal.stop" do
+      helper.at_exit_hook
+      expect(Appsignal).to have_received(:stop).with("rake")
+    end
+  end
+end