appsignal 3.10.0-java → 3.12.0-java

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

@@ -0,0 +1,167 @@
+require "appsignal/integrations/shoryuken"
+
+describe Appsignal::Integrations::ShoryukenMiddleware do
+  class DemoShoryukenWorker
+  end
+
+  let(:time) { "2010-01-01 10:01:00UTC" }
+  let(:worker_instance) { DemoShoryukenWorker.new }
+  let(:queue) { "some-funky-queue-name" }
+  let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
+  let(:body) { {} }
+  before { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def perform_shoryuken_job(&block)
+    block ||= lambda {}
+    Timecop.freeze(Time.parse(time)) do
+      described_class.new.call(
+        worker_instance,
+        queue,
+        sqs_msg,
+        body,
+        &block
+      )
+    end
+  end
+
+  context "with a performance call" do
+    let(:sent_timestamp) { Time.parse("1976-11-18 0:00:00UTC").to_i * 1000 }
+    let(:sqs_msg) do
+      double(:message_id => "msg1", :attributes => { "SentTimestamp" => sent_timestamp })
+    end
+
+    context "with complex argument" do
+      let(:body) { { :foo => "Foo", :bar => "Bar" } }
+
+      it "wraps the job in a transaction with the correct params" do
+        expect { perform_shoryuken_job }.to change { created_transactions.length }.by(1)
+
+        transaction = last_transaction
+        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,
+          "count" => 1,
+          "name" => "perform_job.shoryuken",
+          "title" => ""
+        )
+        expect(transaction).to include_params("foo" => "Foo", "bar" => "Bar")
+        expect(transaction).to include_tags(
+          "message_id" => "msg1",
+          "queue" => queue,
+          "SentTimestamp" => sent_timestamp
+        )
+        expect(transaction).to have_queue_start(sent_timestamp)
+        expect(transaction).to be_completed
+      end
+
+      context "with parameter filtering" do
+        before do
+          start_agent("production")
+          Appsignal.config[:filter_parameters] = ["foo"]
+        end
+
+        it "filters selected arguments" do
+          perform_shoryuken_job
+
+          expect(last_transaction).to include_params("foo" => "[FILTERED]", "bar" => "Bar")
+        end
+      end
+    end
+
+    context "with a string as an argument" do
+      let(:body) { "foo bar" }
+
+      it "handles string arguments" do
+        perform_shoryuken_job
+
+        expect(last_transaction).to include_params("params" => body)
+      end
+    end
+
+    context "with primitive type as argument" do
+      let(:body) { 1 }
+
+      it "handles primitive types as arguments" do
+        perform_shoryuken_job
+
+        expect(last_transaction).to include_params("params" => body)
+      end
+    end
+  end
+
+  context "with exception" do
+    it "sets the exception on the transaction" do
+      expect do
+        expect do
+          perform_shoryuken_job { raise ExampleException, "error message" }
+        end.to raise_error(ExampleException)
+      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
+    end
+  end
+
+  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
+    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 }
+
+    it "creates a transaction for the batch" do
+      expect do
+        perform_shoryuken_job {} # rubocop:disable Lint/EmptyBlock
+      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_not have_error
+      expect(transaction).to include_event(
+        "body" => "",
+        "body_format" => Appsignal::EventFormatter::DEFAULT,
+        "count" => 1,
+        "name" => "perform_job.shoryuken",
+        "title" => ""
+      )
+      expect(transaction).to include_params(
+        "msg2" => "foo bar",
+        "msg1" => { "id" => "123", "foo" => "Foo", "bar" => "Bar" }
+      )
+      expect(transaction).to include_tags(
+        "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_queue_start(sent_timestamp)
+    end
+  end
+end

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

@@ -243,7 +243,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
 
   context "with parameter filtering" do
     before do
-      Appsignal.config = project_fixture_config("production")
+      start_agent("production")
       Appsignal.config[:filter_parameters] = ["foo"]
     end
 
@@ -362,7 +362,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         perform_sidekiq_job { raise error, "uh oh" }
       end.to raise_error(error)
 
-      expect(transaction).to have_id(jid)
+      expect(transaction).to have_id
       expect(transaction).to have_namespace(namespace)
       expect(transaction).to have_action("TestClass#perform")
       expect(transaction).to have_error("ExampleException", "uh oh")
@@ -373,7 +373,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       )
       expect(transaction).to_not include_environment
       expect(transaction).to include_params(expected_args)
-      expect(transaction).to_not include_tags
+      expect(transaction).to include_tags("request_id" => jid)
       expect(transaction).to_not include_breadcrumbs
       expect_transaction_to_have_sidekiq_event(transaction)
     end
@@ -384,7 +384,7 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
       include RailsHelper
 
       it "reports the worker name as the action, copies the namespace and tags" do
-        Appsignal.config = project_fixture_config("production")
+        start_agent("production")
         with_rails_error_reporter do
           perform_sidekiq_job do
             Appsignal.tag_job("test_tag" => "value")
@@ -418,11 +418,11 @@ describe Appsignal::Integrations::SidekiqMiddleware, :with_yaml_parse_error => f
         .with("sidekiq_queue_job_count", 1, { :queue => "default", :status => :processed })
       perform_sidekiq_job
 
-      expect(transaction).to have_id(jid)
+      expect(transaction).to have_id
       expect(transaction).to have_namespace(namespace)
       expect(transaction).to have_action("TestClass#perform")
       expect(transaction).to_not have_error
-      expect(transaction).to_not include_tags
+      expect(transaction).to include_tags("request_id" => jid)
       expect(transaction).to_not include_environment
       expect(transaction).to_not include_breadcrumbs
       expect(transaction).to_not include_params(expected_args)
@@ -527,6 +527,15 @@ if DependencyHelper.active_job_present?
       end
     end
     around do |example|
+      with_rails_error_reporter do
+        keep_transactions do
+          Sidekiq::Testing.fake! do
+            example.run
+          end
+        end
+      end
+    end
+    before do
       start_agent
       Appsignal.internal_logger = test_logger(log)
       ActiveJob::Base.queue_adapter = :sidekiq
@@ -551,13 +560,6 @@ if DependencyHelper.active_job_present?
       Sidekiq::Testing.server_middleware do |chain|
         chain.add Appsignal::Integrations::SidekiqMiddleware
       end
-      with_rails_error_reporter do
-        keep_transactions do
-          Sidekiq::Testing.fake! do
-            example.run
-          end
-        end
-      end
     end
     after do
       Object.send(:remove_const, :ActiveJobSidekiqTestJob)

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

@@ -1,110 +1,15 @@
-if DependencyHelper.sinatra_present?
-  require "appsignal/integrations/sinatra"
-
-  def install_sinatra_integration
-    load File.expand_path("lib/appsignal/integrations/sinatra.rb", project_dir)
-  end
-
-  # "Uninstall" the AppSignal integration
-  def uninstall_sinatra_integration
-    expected_middleware = [
-      Rack::Events,
-      Appsignal::Rack::SinatraBaseInstrumentation
-    ]
-    Sinatra::Base.instance_variable_get(:@middleware).delete_if do |middleware|
-      expected_middleware.include?(middleware.first)
-    end
-  end
-
+if DependencyHelper.padrino_present?
   describe "Sinatra integration" do
-    before do
-      Appsignal.config = nil
-    end
-    after { uninstall_sinatra_integration }
-
-    context "when active" do
-      before { allow(Appsignal).to receive(:active?).and_return(true) }
-
-      it "does not start AppSignal again" do
-        expect(Appsignal::Config).to_not receive(:new)
-        expect(Appsignal).to_not receive(:start)
-        install_sinatra_integration
-      end
-
-      it "adds the instrumentation middleware to Sinatra::Base" do
-        install_sinatra_integration
-        middlewares = Sinatra::Base.middleware.to_a
-        expect(middlewares).to include(
-          [Rack::Events, [[instance_of(Appsignal::Rack::EventHandler)]], nil]
-        )
-        expect(middlewares).to include(
-          [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-        )
-      end
-    end
-
-    context "when not active" do
-      context "Appsignal.internal_logger" do
-        subject { Appsignal.internal_logger }
-
-        it "sets a logger" do
-          install_sinatra_integration
-          is_expected.to be_a Logger
-        end
-      end
-
-      describe "middleware" do
-        context "when AppSignal is not active" do
-          it "does not add the instrumentation middleware to Sinatra::Base" do
-            install_sinatra_integration
-            middlewares = Sinatra::Base.middleware.to_a
-            expect(middlewares).to_not include(
-              [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-            )
-            expect(middlewares).to_not include(
-              [Rack::Events, [Appsignal::Rack::EventHandler], nil]
-            )
-          end
-        end
-
-        context "when the new AppSignal config is active" do
-          it "adds the instrumentation middleware to Sinatra::Base" do
-            ENV["APPSIGNAL_APP_NAME"] = "My Sinatra app name"
-            ENV["APPSIGNAL_APP_ENV"] = "test"
-            ENV["APPSIGNAL_PUSH_API_KEY"] = "my-key"
-
-            install_sinatra_integration
-            middlewares = Sinatra::Base.middleware.to_a
-            expect(middlewares).to include(
-              [Rack::Events, [[Appsignal::Rack::EventHandler]], nil],
-              [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-            )
-          end
-        end
-      end
-
-      describe "environment" do
-        subject { Appsignal.config.env }
-
-        context "without APPSIGNAL_APP_ENV" do
-          before { install_sinatra_integration }
-
-          it "uses the app environment" do
-            expect(subject).to eq("test")
-          end
-        end
+    it "loads the Sinatra loader" do
+      ENV["APPSIGNAL_APP_NAME"] = "test/sinatra"
+      ENV["APPSIGNAL_PUSH_API_KEY"] = "test-key"
 
-        context "with APPSIGNAL_APP_ENV" do
-          before do
-            ENV["APPSIGNAL_APP_ENV"] = "env-staging"
-            install_sinatra_integration
-          end
+      require "appsignal/integrations/sinatra"
 
-          it "uses the environment variable" do
-            expect(subject).to eq("env-staging")
-          end
-        end
-      end
+      expect(Appsignal::Loaders.instances).to include(
+        :sinatra => kind_of(Appsignal::Loaders::SinatraLoader)
+      )
+      expect(Appsignal.active?).to be(true)
     end
   end
 end

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

@@ -18,7 +18,11 @@ if DependencyHelper.webmachine_present?
       Webmachine::Request.new(
         "GET",
         "http://google.com:80/foo?param1=value1&param2=value2",
-        {},
+        {
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/some/path",
+          "ignored_header" => "something"
+        },
         nil
       )
     end
@@ -81,6 +85,14 @@ if DependencyHelper.webmachine_present?
         expect(last_transaction).to include_params("param1" => "value1", "param2" => "value2")
       end
 
+      it "sets the headers" do
+        fsm.run
+        expect(last_transaction).to include_environment(
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/some/path"
+        )
+      end
+
       it "closes the transaction" do
         fsm.run
         expect(last_transaction).to be_completed

data/spec/lib/appsignal/loaders/grape_spec.rb

@@ -0,0 +1,12 @@
+if DependencyHelper.grape_present?
+  describe "Appsignal::Loaders::PadrinoLoader" do
+    describe "#on_load" do
+      it "ensures the Grape middleware is loaded" do
+        load_loader(:grape)
+
+        # Calling this doesn't raise a NameError
+        Appsignal::Rack::GrapeMiddleware
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+if DependencyHelper.hanami_present?
+  describe "Appsignal::Loaders::HanamiLoader" do
+    before { Appsignal.config = nil }
+
+    describe "#on_load" do
+      it "registers Hanami default config" do
+        load_loader(:hanami)
+
+        expect(Appsignal::Config.loader_defaults).to include([
+          :hanami,
+          {
+            :env => :test,
+            :root_path => Dir.pwd
+          }
+        ])
+      end
+    end
+
+    describe "#on_start" do
+      before do
+        allow(::Hanami::Action).to receive(:prepend)
+        load_loader(:hanami)
+        start_loader(:hanami)
+      end
+      after { uninstall_hanami_middleware }
+
+      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
+
+      it "adds the instrumentation middleware to Sinatra::Base" do
+        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
+
+      it "prepends the integration to Hanami::Action" do
+        expect(::Hanami::Action)
+          .to have_received(:prepend).with(Appsignal::Loaders::HanamiLoader::HanamiIntegration)
+      end
+
+      def hanami_middleware_options
+        if DependencyHelper.hanami2_1_present?
+          [{}, nil]
+        else
+          [nil]
+        end
+      end
+    end
+
+    describe "Appsignal::Loaders::HanamiLoader::HanamiIntegration" do
+      let(:transaction) { http_request_transaction }
+      let(:app) { HanamiApp::Actions::Books::Index }
+      around { |example| keep_transactions { example.run } }
+      before do
+        expect(::Hanami.app.config).to receive(:root).and_return(project_fixture_path)
+        Appsignal.load(:hanami)
+        start_agent
+      end
+
+      def make_request(env)
+        action = app.new
+        action.call(env)
+      end
+
+      describe "#call" do
+        context "without an active transaction" do
+          let(:env) { {} }
+
+          it "does not set the action name" do
+            make_request(env)
+
+            expect(transaction).to_not have_action
+          end
+        end
+
+        context "with an active transaction" do
+          let(:env) { { Appsignal::Rack::APPSIGNAL_TRANSACTION => transaction } }
+
+          it "sets action name on the transaction" do
+            make_request(env)
+
+            expect(transaction).to have_action("HanamiApp::Actions::Books::Index")
+          end
+        end
+      end
+    end
+  end
+end