appsignal 3.9.1-java → 3.9.3-java

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

@@ -53,20 +53,14 @@ describe Appsignal::Hooks::ResqueHook do
         perform_rescue_job(ResqueTestJob)
 
         transaction = last_transaction
-        transaction_hash = transaction.to_h
-        expect(transaction_hash).to include(
-          "id" => kind_of(String),
-          "action" => "ResqueTestJob#perform",
-          "error" => nil,
-          "namespace" => namespace,
-          "metadata" => {},
-          "sample_data" => {
-            "breadcrumbs" => [],
-            "tags" => { "queue" => queue }
-          }
-        )
-        expect(transaction_hash["events"].map { |e| e["name"] })
-          .to eql(["perform.resque"])
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(namespace)
+        expect(transaction).to have_action("ResqueTestJob#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to_not include_metadata
+        expect(transaction).to_not include_breadcrumbs
+        expect(transaction).to include_tags("queue" => queue)
+        expect(transaction).to include_event("name" => "perform.resque")
       end
 
       context "with error" do
@@ -76,22 +70,14 @@ describe Appsignal::Hooks::ResqueHook do
           end.to raise_error(RuntimeError, "resque job error")
 
           transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "id" => kind_of(String),
-            "action" => "ResqueErrorTestJob#perform",
-            "error" => {
-              "name" => "RuntimeError",
-              "message" => "resque job error",
-              "backtrace" => kind_of(String)
-            },
-            "namespace" => namespace,
-            "metadata" => {},
-            "sample_data" => {
-              "breadcrumbs" => [],
-              "tags" => { "queue" => queue }
-            }
-          )
+          expect(transaction).to have_id
+          expect(transaction).to have_namespace(namespace)
+          expect(transaction).to have_action("ResqueErrorTestJob#perform")
+          expect(transaction).to have_error("RuntimeError", "resque job error")
+          expect(transaction).to_not include_metadata
+          expect(transaction).to_not include_breadcrumbs
+          expect(transaction).to include_tags("queue" => queue)
+          expect(transaction).to include_event("name" => "perform.resque")
         end
       end
 
@@ -115,25 +101,23 @@ describe Appsignal::Hooks::ResqueHook do
           )
 
           transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "id" => kind_of(String),
-            "action" => "ResqueTestJob#perform",
-            "error" => nil,
-            "namespace" => namespace,
-            "metadata" => {},
-            "sample_data" => {
-              "tags" => { "queue" => queue },
-              "breadcrumbs" => [],
-              "params" => [
-                "foo",
-                {
-                  "foo" => "[FILTERED]",
-                  "bar" => "Bar",
-                  "baz" => { "1" => "foo" }
-                }
-              ]
-            }
+          expect(transaction).to have_id
+          expect(transaction).to have_namespace(namespace)
+          expect(transaction).to have_action("ResqueTestJob#perform")
+          expect(transaction).to_not have_error
+          expect(transaction).to_not include_metadata
+          expect(transaction).to_not include_breadcrumbs
+          expect(transaction).to include_tags("queue" => queue)
+          expect(transaction).to include_event("name" => "perform.resque")
+          expect(transaction).to include_params(
+            [
+              "foo",
+              {
+                "foo" => "[FILTERED]",
+                "bar" => "Bar",
+                "baz" => { "1" => "foo" }
+              }
+            ]
           )
         end
       end
@@ -173,19 +157,15 @@ describe Appsignal::Hooks::ResqueHook do
           )
 
           transaction = last_transaction
-          transaction_hash = transaction.to_h
-          expect(transaction_hash).to include(
-            "id" => kind_of(String),
-            "action" => "ResqueTestJobByActiveJob#perform",
-            "error" => nil,
-            "namespace" => namespace,
-            "metadata" => {},
-            "sample_data" => {
-              "breadcrumbs" => [],
-              "tags" => { "queue" => queue }
-              # Params will be set by the ActiveJob integration
-            }
-          )
+          expect(transaction).to have_id
+          expect(transaction).to have_namespace(namespace)
+          expect(transaction).to have_action("ResqueTestJobByActiveJob#perform")
+          expect(transaction).to_not have_error
+          expect(transaction).to_not include_metadata
+          expect(transaction).to_not include_breadcrumbs
+          expect(transaction).to include_tags("queue" => queue)
+          expect(transaction).to include_event("name" => "perform.resque")
+          expect(transaction).to_not include_params
         end
       end
     end

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

@@ -37,37 +37,25 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
         expect { perform_shoryuken_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),
+        expect(transaction).to have_id
+        expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+        expect(transaction).to have_action("DemoShoryukenWorker#perform")
+        expect(transaction).to_not have_error
+        expect(transaction).to include_event(
           "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 include_params("foo" => "Foo", "bar" => "Bar")
+        expect(transaction).to include_sample_metadata(
+          "message_id" => "msg1",
+          "queue" => queue,
+          "SentTimestamp" => sent_timestamp
         )
-        expect(transaction).to have_received(:set_queue_start).with(sent_timestamp)
+        expect(transaction).to have_queue_start(sent_timestamp)
+        expect(transaction).to be_completed
       end
 
       context "with parameter filtering" do
@@ -82,10 +70,7 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
         it "filters selected arguments" do
           perform_shoryuken_job
 
-          transaction_hash = last_transaction.to_h
-          expect(transaction_hash["sample_data"]).to include(
-            "params" => { "foo" => "[FILTERED]", "bar" => "Bar" }
-          )
+          expect(last_transaction).to include_params("foo" => "[FILTERED]", "bar" => "Bar")
         end
       end
     end
@@ -96,10 +81,7 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       it "handles string arguments" do
         perform_shoryuken_job
 
-        transaction_hash = last_transaction.to_h
-        expect(transaction_hash["sample_data"]).to include(
-          "params" => { "params" => body }
-        )
+        expect(last_transaction).to include_params("params" => body)
       end
     end
 
@@ -109,10 +91,7 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       it "handles primitive types as arguments" do
         perform_shoryuken_job
 
-        transaction_hash = last_transaction.to_h
-        expect(transaction_hash["sample_data"]).to include(
-          "params" => { "params" => body }
-        )
+        expect(last_transaction).to include_params("params" => body)
       end
     end
   end
@@ -126,18 +105,11 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       end.to change { created_transactions.length }.by(1)
 
       transaction = last_transaction
+      expect(transaction).to have_id
+      expect(transaction).to have_action("DemoShoryukenWorker#perform")
+      expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+      expect(transaction).to have_error("ExampleException", "error message")
       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
 
@@ -171,41 +143,28 @@ describe Appsignal::Hooks::ShoryukenMiddleware do
       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),
+      expect(transaction).to have_id
+      expect(transaction).to have_action("DemoShoryukenWorker#perform")
+      expect(transaction).to have_namespace(Appsignal::Transaction::BACKGROUND_JOB)
+      expect(transaction).to_not have_error
+      expect(transaction).to include_event(
         "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
-        }
+      expect(transaction).to include_params(
+        "msg2" => "foo bar",
+        "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+      )
+      expect(transaction).to include_sample_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)
+      expect(transaction).to have_queue_start(sent_timestamp)
     end
   end
 end

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

@@ -5,32 +5,106 @@ if DependencyHelper.hanami2_present?
     require "appsignal/integrations/hanami"
 
     before do
-      allow(Appsignal).to receive(:active?).and_return(true)
-      allow(Appsignal).to receive(:start).and_return(true)
-      allow(Appsignal).to receive(:start_logger).and_return(true)
+      Appsignal.config = nil
+      allow(::Hanami::Action).to receive(:prepend)
+      uninstall_hanami_middleware
+      ENV["APPSIGNAL_APP_NAME"] = "hanamia-test-app"
+      ENV["APPSIGNAL_APP_ENV"] = "test"
+      ENV["APPSIGNAL_PUSH_API_KEY"] = "0000"
+    end
+
+    def uninstall_hanami_middleware
+      middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
+      middleware_stack.delete_if do |middleware|
+        middleware.first == Appsignal::Rack::HanamiMiddleware ||
+          middleware.first == Rack::Events
+      end
     end
 
     describe Appsignal::Integrations::HanamiPlugin do
       it "starts AppSignal on init" do
-        expect(Appsignal).to receive(:start)
+        expect(Appsignal.active?).to be_falsey
+
+        Appsignal::Integrations::HanamiPlugin.init
+
+        expect(Appsignal.active?).to be_truthy
       end
 
-      it "starts the logger on init" do
-        expect(Appsignal).to receive(:start_logger)
+      it "prepends the integration to Hanami::Action" do
+        Appsignal::Integrations::HanamiPlugin.init
+
+        expect(::Hanami::Action)
+          .to have_received(:prepend).with(Appsignal::Integrations::HanamiIntegration)
       end
 
-      it "prepends the integration to Hanami" do
-        expect(::Hanami::Action).to receive(:prepend)
-          .with(Appsignal::Integrations::HanamiIntegration)
+      it "adds middleware to the Hanami app" do
+        Appsignal::Integrations::HanamiPlugin.init
+
+        expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
+          .to include(
+            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], *hanami_middleware_options],
+            [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
+          )
       end
 
       context "when not active" do
-        before { allow(Appsignal).to receive(:active?).and_return(false) }
+        before do
+          ENV.delete("APPSIGNAL_APP_NAME")
+          ENV.delete("APPSIGNAL_APP_ENV")
+          ENV.delete("APPSIGNAL_PUSH_API_KEY")
+        end
+
+        it "does not prepend the integration to Hanami::Action" do
+          Appsignal::Integrations::HanamiPlugin.init
 
-        it "does not prepend the integration" do
-          expect(::Hanami::Action).to_not receive(:prepend)
+          expect(::Hanami::Action).to_not have_received(:prepend)
             .with(Appsignal::Integrations::HanamiIntegration)
         end
+
+        it "does not add the middleware to the Hanami app" do
+          Appsignal::Integrations::HanamiPlugin.init
+
+          middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
+          expect(middleware_stack).to_not include(
+            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], *hanami_middleware_options]
+          )
+          expect(middleware_stack).to_not include(
+            [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
+          )
+        end
+      end
+
+      context "when AppSignal is already active" do
+        before do
+          expect(Appsignal).to receive(:active?).at_least(1).and_return(true)
+        end
+
+        it "does not initialize AppSignal again" do
+          expect(Appsignal).to_not receive(:start)
+
+          Appsignal::Integrations::HanamiPlugin.init
+        end
+
+        it "prepends the integration to Hanami::Action" do
+          Appsignal::Integrations::HanamiPlugin.init
+
+          expect(::Hanami::Action)
+            .to have_received(:prepend).with(Appsignal::Integrations::HanamiIntegration)
+        end
+
+        it "adds middleware to the Hanami app" do
+          Appsignal::Integrations::HanamiPlugin.init
+
+          expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
+            .to include(
+              [
+                Rack::Events,
+                [[kind_of(Appsignal::Rack::EventHandler)]],
+                *hanami_middleware_options
+              ],
+              [Appsignal::Rack::HanamiMiddleware, [], *hanami_middleware_options]
+            )
+        end
       end
 
       context "when APPSIGNAL_APP_ENV ENV var is provided" do
@@ -52,72 +126,60 @@ if DependencyHelper.hanami2_present?
           expect(Appsignal.config.env).to eq("test")
         end
       end
-
-      after { Appsignal::Integrations::HanamiPlugin.init }
     end
 
-    describe "Hanami Actions" do
-      let(:env) do
-        Rack::MockRequest.env_for(
-          "/books",
-          "router.params" => router_params,
-          :method => "GET"
-        )
+    describe Appsignal::Integrations::HanamiIntegration do
+      let(:transaction) { http_request_transaction }
+      let(:app) do
+        Class.new(HanamiApp::Actions::Books::Index) do
+          def self.name
+            "HanamiApp::Actions::Books::Index::TestClass"
+          end
+        end
+      end
+      around { |example| keep_transactions { example.run } }
+      before do
+        ENV["APPSIGNAL_APP_NAME"] = "hanamia-test-app"
+        ENV["APPSIGNAL_APP_ENV"] = "test"
+        ENV["APPSIGNAL_PUSH_API_KEY"] = "0000"
+        Appsignal::Integrations::HanamiPlugin.init
+        allow(app).to receive(:prepend).and_call_original
+        app.prepend(Appsignal::Integrations::HanamiIntegration)
       end
 
-      let(:router_params) { { :foo => "bar", :baz => "qux" } }
-
-      describe "#call", :error => false do
-        it "sets params" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:params=).with(router_params)
-        end
+      def make_request(env)
+        action = app.new
+        action.call(env)
+      end
 
-        it "sets the action name" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil)
-            .with("HanamiApp::Actions::Books::Index")
-        end
+      describe "#call" do
+        context "without an active transaction" do
+          let(:env) { {} }
 
-        it "sets the metadata" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-            .with("status", "200")
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-            .with("path", "/books")
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-            .with("method", "GET")
-        end
+          it "does not set the action name" do
+            make_request(env)
 
-        it "sets the queue start" do
-          expect_any_instance_of(Appsignal::Transaction)
-            .to receive(:set_http_or_background_queue_start)
+            expect(transaction).to_not have_action
+          end
         end
 
-        context "with error", :error => true do
-          let(:error) { HanamiApp::ExampleError }
+        context "with an active transaction" do
+          let(:env) { { Appsignal::Rack::APPSIGNAL_TRANSACTION => transaction } }
 
-          it "records the exception" do
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
-          end
+          it "sets action name on the transaction" do
+            make_request(env)
 
-          it "sets the status to 500" do
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-              .with("status", "500")
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+            expect(transaction).to have_action("HanamiApp::Actions::Books::Index::TestClass")
           end
         end
+      end
+    end
 
-        after(:error => false) do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          action = HanamiApp::Actions::Books::Index.new
-          action.call(env)
-        end
-
-        after(:error => true) do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          action = HanamiApp::Actions::Books::Error.new
-          expect { action.call(env) }.to raise_error(error)
-        end
+    def hanami_middleware_options
+      if DependencyHelper.hanami2_1_present?
+        [{}, nil]
+      else
+        [nil]
       end
     end
   end

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

@@ -23,9 +23,8 @@ if DependencyHelper.http_present?
 
       HTTP.get("http://www.google.com")
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include("namespace" => Appsignal::Transaction::HTTP_REQUEST)
-      expect(transaction_hash["events"].first).to include(
+      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+      expect(transaction).to include_event(
         "body" => "",
         "body_format" => Appsignal::EventFormatter::DEFAULT,
         "name" => "request.http_rb",
@@ -38,9 +37,8 @@ if DependencyHelper.http_present?
 
       HTTP.get("https://www.google.com")
 
-      transaction_hash = transaction.to_h
-      expect(transaction_hash).to include("namespace" => Appsignal::Transaction::HTTP_REQUEST)
-      expect(transaction_hash["events"].first).to include(
+      expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+      expect(transaction).to include_event(
         "body" => "",
         "body_format" => Appsignal::EventFormatter::DEFAULT,
         "name" => "request.http_rb",
@@ -54,7 +52,7 @@ if DependencyHelper.http_present?
 
         HTTP.get("https://www.google.com", :params => { :q => "Appsignal" })
 
-        expect(transaction.to_h["events"].first).to include(
+        expect(transaction).to include_event(
           "body" => "",
           "title" => "GET https://www.google.com"
         )
@@ -66,7 +64,7 @@ if DependencyHelper.http_present?
 
         HTTP.post("https://www.google.com", :json => { :q => "Appsignal" })
 
-        expect(transaction.to_h["events"].first).to include(
+        expect(transaction).to include_event(
           "body" => "",
           "title" => "POST https://www.google.com"
         )
@@ -83,20 +81,14 @@ if DependencyHelper.http_present?
           HTTP.get("https://www.google.com")
         end.to raise_error(ExampleException)
 
-        transaction_hash = transaction.to_h
-        expect(transaction_hash).to include("namespace" => Appsignal::Transaction::HTTP_REQUEST)
-        expect(transaction_hash["events"].first).to include(
+        expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+        expect(transaction).to include_event(
           "body" => "",
           "body_format" => Appsignal::EventFormatter::DEFAULT,
           "name" => "request.http_rb",
           "title" => "GET https://www.google.com"
         )
-
-        expect(transaction_hash["error"]).to include(
-          "backtrace" => kind_of(String),
-          "name" => error.class.name,
-          "message" => error.message
-        )
+        expect(transaction).to have_error(error.class.name, error.message)
       end
     end
 
@@ -112,7 +104,7 @@ if DependencyHelper.http_present?
 
         HTTP.get(request_uri.new("http://www.google.com"))
 
-        expect(transaction.to_h["events"].first).to include(
+        expect(transaction).to include_event(
           "name" => "request.http_rb",
           "title" => "GET http://www.google.com"
         )
@@ -123,7 +115,7 @@ if DependencyHelper.http_present?
 
         HTTP.get(URI("http://www.google.com"))
 
-        expect(transaction.to_h["events"].first).to include(
+        expect(transaction).to include_event(
           "name" => "request.http_rb",
           "title" => "GET http://www.google.com"
         )
@@ -134,7 +126,7 @@ if DependencyHelper.http_present?
 
         HTTP.get("http://www.google.com")
 
-        expect(transaction.to_h["events"].first).to include(
+        expect(transaction).to include_event(
           "name" => "request.http_rb",
           "title" => "GET http://www.google.com"
         )

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

@@ -0,0 +1,33 @@
+require "appsignal/integrations/net_http"
+
+describe Appsignal::Integrations::NetHttpIntegration do
+  let(:transaction) { http_request_transaction }
+  before(:context) { start_agent }
+  before { set_current_transaction transaction }
+  around { |example| keep_transactions { example.run } }
+
+  it "instruments a http request" do
+    stub_request(:any, "http://www.google.com/")
+
+    Net::HTTP.get_response(URI.parse("http://www.google.com"))
+
+    expect(transaction).to include_event(
+      "name" => "request.net_http",
+      "title" => "GET http://www.google.com"
+    )
+  end
+
+  it "instruments a https request" do
+    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)
+
+    expect(transaction).to include_event(
+      "name" => "request.net_http",
+      "title" => "GET https://www.google.com"
+    )
+  end
+end