appsignal 3.9.2-java → 3.10.0-java

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

@@ -88,13 +88,10 @@ describe Appsignal::Hooks::RedisClientHook do
                 connection = RedisClient::RubyConnection.new client_config
                 expect(connection.write([:get, "key"])).to eql("stub_write")
 
-                transaction_hash = transaction.to_h
-                expect(transaction_hash["events"]).to include(
-                  hash_including(
-                    "name" => "query.redis",
-                    "body" => "get ?",
-                    "title" => "stub_id"
-                  )
+                expect(transaction).to include_event(
+                  "name" => "query.redis",
+                  "body" => "get ?",
+                  "title" => "stub_id"
                 )
               end
 
@@ -103,16 +100,13 @@ describe Appsignal::Hooks::RedisClientHook do
                 script = "return redis.call('set',KEYS[1],ARGV[1])"
                 keys = ["foo"]
                 argv = ["bar"]
-                expect(connection.write([:eval, script, keys.size, keys,
-                                         argv])).to eql("stub_write")
+                expect(connection.write([:eval, script, keys.size, keys, argv]))
+                  .to eql("stub_write")
 
-                transaction_hash = transaction.to_h
-                expect(transaction_hash["events"]).to include(
-                  hash_including(
-                    "name" => "query.redis",
-                    "body" => "#{script} ? ?",
-                    "title" => "stub_id"
-                  )
+                expect(transaction).to include_event(
+                  "name" => "query.redis",
+                  "body" => "#{script} ? ?",
+                  "title" => "stub_id"
                 )
               end
             end
@@ -181,13 +175,10 @@ describe Appsignal::Hooks::RedisClientHook do
                   connection = RedisClient::HiredisConnection.new client_config
                   expect(connection.write([:get, "key"])).to eql("stub_write")
 
-                  transaction_hash = transaction.to_h
-                  expect(transaction_hash["events"]).to include(
-                    hash_including(
-                      "name" => "query.redis",
-                      "body" => "get ?",
-                      "title" => "stub_id"
-                    )
+                  expect(transaction).to include_event(
+                    "name" => "query.redis",
+                    "body" => "get ?",
+                    "title" => "stub_id"
                   )
                 end
 
@@ -199,13 +190,10 @@ describe Appsignal::Hooks::RedisClientHook do
                   expect(connection.write([:eval, script, keys.size, keys,
                                            argv])).to eql("stub_write")
 
-                  transaction_hash = transaction.to_h
-                  expect(transaction_hash["events"]).to include(
-                    hash_including(
-                      "name" => "query.redis",
-                      "body" => "#{script} ? ?",
-                      "title" => "stub_id"
-                    )
+                  expect(transaction).to include_event(
+                    "name" => "query.redis",
+                    "body" => "#{script} ? ?",
+                    "title" => "stub_id"
                   )
                 end
               end

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

@@ -81,14 +81,11 @@ describe Appsignal::Hooks::RedisHook do
                 client = Redis::Client.new
                 expect(client.write([:get, "key"])).to eql("stub_write")
 
-                transaction_hash = transaction.to_h
-                expect(transaction_hash["events"]).to include(
-                                                        hash_including(
-                                                          "name" => "query.redis",
-                                                          "body" => "get ?",
-                                                          "title" => "stub_id"
-                                                        )
-                                                      )
+                expect(transaction).to include_event(
+                  "name" => "query.redis",
+                  "body" => "get ?",
+                  "title" => "stub_id"
+                )
               end
 
               it "instrument a redis script call" do
@@ -98,14 +95,11 @@ describe Appsignal::Hooks::RedisHook do
                 argv = ["bar"]
                 expect(client.write([:eval, script, keys.size, keys, argv])).to eql("stub_write")
 
-                transaction_hash = transaction.to_h
-                expect(transaction_hash["events"]).to include(
-                                                        hash_including(
-                                                          "name" => "query.redis",
-                                                          "body" => "#{script} ? ?",
-                                                          "title" => "stub_id"
-                                                        )
-                                                      )
+                expect(transaction).to include_event(
+                  "name" => "query.redis",
+                  "body" => "#{script} ? ?",
+                  "title" => "stub_id"
+                )
               end
             end
           end

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,7 +5,12 @@ if DependencyHelper.hanami2_present?
     require "appsignal/integrations/hanami"
 
     before do
+      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
@@ -18,35 +23,41 @@ if DependencyHelper.hanami2_present?
 
     describe Appsignal::Integrations::HanamiPlugin do
       it "starts AppSignal on init" do
-        expect(Appsignal).to receive(:start)
-        expect(Appsignal).to receive(:start_logger)
+        expect(Appsignal.active?).to be_falsey
+
         Appsignal::Integrations::HanamiPlugin.init
+
+        expect(Appsignal.active?).to be_truthy
       end
 
       it "prepends the integration to Hanami::Action" do
-        allow(Appsignal).to receive(:active?).and_return(true)
         Appsignal::Integrations::HanamiPlugin.init
-        expect(::Hanami::Action.included_modules)
-          .to include(Appsignal::Integrations::HanamiIntegration)
+
+        expect(::Hanami::Action)
+          .to have_received(:prepend).with(Appsignal::Integrations::HanamiIntegration)
       end
 
       it "adds middleware to the Hanami app" do
-        allow(Appsignal).to receive(:active?).and_return(true)
         Appsignal::Integrations::HanamiPlugin.init
 
         expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
           .to include(
-            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], nil],
-            [Appsignal::Rack::HanamiMiddleware, [], nil]
+            [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
-          expect(::Hanami::Action).to_not receive(:prepend)
+
+          expect(::Hanami::Action).to_not have_received(:prepend)
             .with(Appsignal::Integrations::HanamiIntegration)
         end
 
@@ -55,14 +66,47 @@ if DependencyHelper.hanami2_present?
 
           middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
           expect(middleware_stack).to_not include(
-            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], nil]
+            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], *hanami_middleware_options]
           )
           expect(middleware_stack).to_not include(
-            [Appsignal::Rack::HanamiMiddleware, [], nil]
+            [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
         it "uses this as the environment" do
           ENV["APPSIGNAL_APP_ENV"] = "custom"
@@ -86,14 +130,24 @@ if DependencyHelper.hanami2_present?
 
     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(:context) { start_agent }
       before do
-        allow(Appsignal).to receive(:active?).and_return(true)
+        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
 
-      def make_request(env, app: HanamiApp::Actions::Books::Index)
+      def make_request(env)
         action = app.new
         action.call(env)
       end
@@ -105,9 +159,7 @@ if DependencyHelper.hanami2_present?
           it "does not set the action name" do
             make_request(env)
 
-            expect(transaction.to_h).to include(
-              "action" => nil
-            )
+            expect(transaction).to_not have_action
           end
         end
 
@@ -117,12 +169,18 @@ if DependencyHelper.hanami2_present?
           it "sets action name on the transaction" do
             make_request(env)
 
-            expect(transaction.to_h).to include(
-              "action" => "HanamiApp::Actions::Books::Index"
-            )
+            expect(transaction).to have_action("HanamiApp::Actions::Books::Index::TestClass")
           end
         end
       end
     end
+
+    def hanami_middleware_options
+      if DependencyHelper.hanami2_1_present?
+        [{}, nil]
+      else
+        [nil]
+      end
+    end
   end
 end