appsignal 3.8.0-java → 3.9.0-java

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

@@ -1,19 +1,83 @@
 require "appsignal/integrations/sidekiq"
 
-describe Appsignal::Integrations::SidekiqErrorHandler do
-  let(:log) { StringIO.new }
-  before do
-    start_agent
-    Appsignal.internal_logger = test_logger(log)
-  end
+describe Appsignal::Integrations::SidekiqDeathHandler do
+  before { start_agent }
   around { |example| keep_transactions { example.run } }
 
-  context "without a current transaction" do
-    let(:exception) do
-      raise ExampleStandardError, "uh oh"
-    rescue => error
-      error
+  let(:exception) do
+    raise ExampleStandardError, "uh oh"
+  rescue => error
+    error
+  end
+  let(:job_context) { {} }
+  let(:transaction) { http_request_transaction }
+  before { set_current_transaction(transaction) }
+
+  def call_handler
+    expect do
+      described_class.new.call(job_context, exception)
+    end.to_not(change { created_transactions.count })
+  end
+
+  def expect_error_on_transaction
+    expect(last_transaction.to_h).to include(
+      "error" => hash_including(
+        "name" => "ExampleStandardError",
+        "message" => "uh oh",
+        "backtrace" => kind_of(String)
+      )
+    )
+  end
+
+  def expect_no_error_on_transaction
+    expect(last_transaction.to_h).to include("error" => nil)
+  end
+
+  context "when sidekiq_report_errors = none" do
+    before do
+      Appsignal.config[:sidekiq_report_errors] = "none"
+      call_handler
+    end
+
+    it "doesn't track the error on the transaction" do
+      expect_no_error_on_transaction
     end
+  end
+
+  context "when sidekiq_report_errors = all" do
+    before do
+      Appsignal.config[:sidekiq_report_errors] = "all"
+      call_handler
+    end
+
+    it "doesn't track the error on the transaction" do
+      expect_no_error_on_transaction
+    end
+  end
+
+  context "when sidekiq_report_errors = discard" do
+    before do
+      Appsignal.config[:sidekiq_report_errors] = "discard"
+      call_handler
+    end
+
+    it "records each occurrence of the error on the transaction" do
+      expect_error_on_transaction
+    end
+  end
+end
+
+describe Appsignal::Integrations::SidekiqErrorHandler do
+  before { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  let(:exception) do
+    raise ExampleStandardError, "uh oh"
+  rescue => error
+    error
+  end
+
+  context "when error is an internal error" do
     let(:job_context) do
       {
         :context => "Sidekiq internal error!",
@@ -21,14 +85,19 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
       }
     end
 
-    it "tracks error on a new transaction" do
-      described_class.new.call(exception, job_context)
+    def expect_report_internal_error
+      expect do
+        described_class.new.call(exception, job_context)
+      end.to(change { created_transactions.count }.by(1))
 
       transaction_hash = last_transaction.to_h
-      expect(transaction_hash["error"]).to include(
-        "name" => "ExampleStandardError",
-        "message" => "uh oh",
-        "backtrace" => kind_of(String)
+      expect(transaction_hash).to include(
+        "action" => "SidekiqInternal",
+        "error" => hash_including(
+          "name" => "ExampleStandardError",
+          "message" => "uh oh",
+          "backtrace" => kind_of(String)
+        )
       )
       expect(transaction_hash["sample_data"]).to include(
         "params" => {
@@ -39,6 +108,95 @@ describe Appsignal::Integrations::SidekiqErrorHandler do
         "sidekiq_error" => "Sidekiq internal error!"
       )
     end
+
+    context "when sidekiq_report_errors = none" do
+      before { Appsignal.config[:sidekiq_report_errors] = "none" }
+
+      it "tracks the error on a new transaction" do
+        expect_report_internal_error
+      end
+    end
+
+    context "when sidekiq_report_errors = all" do
+      before { Appsignal.config[:sidekiq_report_errors] = "all" }
+
+      it "tracks the error on a new transaction" do
+        expect_report_internal_error
+      end
+    end
+
+    context "when sidekiq_report_errors = discard" do
+      before { Appsignal.config[:sidekiq_report_errors] = "discard" }
+
+      it "tracks the error on a new transaction" do
+        expect_report_internal_error
+      end
+    end
+  end
+
+  context "when error is a job error" do
+    let(:sidekiq_context) { { :job => {} } }
+    let(:transaction) { http_request_transaction }
+    before do
+      transaction.set_action("existing transaction action")
+      set_current_transaction(transaction)
+    end
+
+    def call_handler
+      expect do
+        described_class.new.call(exception, sidekiq_context)
+      end.to_not(change { created_transactions.count })
+    end
+
+    def expect_error_on_transaction
+      expect(last_transaction.to_h).to include(
+        "error" => hash_including(
+          "name" => "ExampleStandardError",
+          "message" => "uh oh",
+          "backtrace" => kind_of(String)
+        )
+      )
+    end
+
+    def expect_no_error_on_transaction
+      expect(last_transaction.to_h).to include("error" => nil)
+    end
+
+    context "when sidekiq_report_errors = none" do
+      before do
+        Appsignal.config[:sidekiq_report_errors] = "none"
+        call_handler
+      end
+
+      it "doesn't track the error on the transaction" do
+        expect_no_error_on_transaction
+        expect(last_transaction).to be_completed
+      end
+    end
+
+    context "when sidekiq_report_errors = all" do
+      before do
+        Appsignal.config[:sidekiq_report_errors] = "all"
+        call_handler
+      end
+
+      it "records each occurrence of the error on the transaction" do
+        expect_error_on_transaction
+        expect(last_transaction).to be_completed
+      end
+    end
+
+    context "when sidekiq_report_errors = discard" do
+      before do
+        Appsignal.config[:sidekiq_report_errors] = "discard"
+        call_handler
+      end
+
+      it "doesn't track the error on the transaction" do
+        expect_no_error_on_transaction
+        expect(last_transaction).to be_completed
+      end
+    end
   end
 end
 

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

@@ -13,59 +13,83 @@ if DependencyHelper.sinatra_present?
   end
 
   describe "Sinatra integration" do
-    before { allow(Appsignal).to receive(:active?).and_return(true) }
+    before do
+      Appsignal.config = nil
+    end
     after { uninstall_sinatra_integration }
 
-    context "Appsignal.internal_logger" do
-      subject { Appsignal.internal_logger }
+    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)
+        expect(Appsignal).to_not receive(:start_logger)
+        install_sinatra_integration
+      end
 
-      it "sets a logger" do
+      it "adds the instrumentation middleware to Sinatra::Base" do
         install_sinatra_integration
-        is_expected.to be_a Logger
+        expect(Sinatra::Base.middleware.to_a).to include(
+          [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+        )
       end
     end
 
-    describe "middleware" do
-      context "when AppSignal is not active" do
-        before { allow(Appsignal).to receive(:active?).and_return(false) }
+    context "when not active" do
+      context "Appsignal.internal_logger" do
+        subject { Appsignal.internal_logger }
 
-        it "does not add the instrumentation middleware to Sinatra::Base" do
+        it "sets a logger" do
           install_sinatra_integration
-          expect(Sinatra::Base.middleware.to_a).to_not include(
-            [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-          )
+          is_expected.to be_a Logger
         end
       end
 
-      context "when AppSignal is active" do
-        it "adds the instrumentation middleware to Sinatra::Base" do
-          install_sinatra_integration
-          expect(Sinatra::Base.middleware.to_a).to include(
-            [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
-          )
+      describe "middleware" do
+        context "when AppSignal is not active" do
+          it "does not add the instrumentation middleware to Sinatra::Base" do
+            install_sinatra_integration
+            expect(Sinatra::Base.middleware.to_a).to_not include(
+              [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+            )
+          end
         end
-      end
-    end
-
-    describe "environment" do
-      subject { Appsignal.config.env }
 
-      context "without APPSIGNAL_APP_ENV" do
-        before { install_sinatra_integration }
+        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"
 
-        it "uses the app environment" do
-          expect(subject).to eq("test")
+            install_sinatra_integration
+            expect(Sinatra::Base.middleware.to_a).to include(
+              [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
+            )
+          end
         end
       end
 
-      context "with APPSIGNAL_APP_ENV" do
-        before do
-          ENV["APPSIGNAL_APP_ENV"] = "env-staging"
-          install_sinatra_integration
+      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 "uses the environment variable" do
-          expect(subject).to eq("env-staging")
+        context "with APPSIGNAL_APP_ENV" do
+          before do
+            ENV["APPSIGNAL_APP_ENV"] = "env-staging"
+            install_sinatra_integration
+          end
+
+          it "uses the environment variable" do
+            expect(subject).to eq("env-staging")
+          end
         end
       end
     end

data/spec/lib/appsignal/rack/abstract_middleware_spec.rb

@@ -0,0 +1,250 @@
+describe Appsignal::Rack::AbstractMiddleware do
+  let(:app) { double(:call => true) }
+  let(:request_path) { "/some/path" }
+  let(:env) do
+    Rack::MockRequest.env_for(
+      request_path,
+      "REQUEST_METHOD" => "GET",
+      :params => { "page" => 2, "query" => "lorem" }
+    )
+  end
+  let(:options) { {} }
+  let(:middleware) { Appsignal::Rack::AbstractMiddleware.new(app, options) }
+
+  before(:context) { start_agent }
+  around { |example| keep_transactions { example.run } }
+
+  def make_request(env)
+    middleware.call(env)
+  end
+
+  def make_request_with_error(env, error)
+    expect { make_request(env) }.to raise_error(error)
+  end
+
+  describe "#call" do
+    context "when appsignal is not active" do
+      before { allow(Appsignal).to receive(:active?).and_return(false) }
+
+      it "does not instrument requests" do
+        expect { make_request(env) }.to_not(change { created_transactions.count })
+      end
+
+      it "calls the next middleware in the stack" do
+        expect(app).to receive(:call).with(env)
+        make_request(env)
+      end
+    end
+
+    context "when appsignal is active" do
+      before { allow(Appsignal).to receive(:active?).and_return(true) }
+
+      it "calls the next middleware in the stack" do
+        make_request(env)
+
+        expect(app).to have_received(:call).with(env)
+      end
+
+      context "without an exception" do
+        it "create a transaction for the request" do
+          expect { make_request(env) }.to(change { created_transactions.count }.by(1))
+
+          expect(last_transaction.to_h).to include(
+            "namespace" => Appsignal::Transaction::HTTP_REQUEST,
+            "action" => nil,
+            "error" => nil
+          )
+        end
+
+        it "reports a process.abstract event" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include(
+            "events" => [
+              hash_including(
+                "body" => "",
+                "body_format" => Appsignal::EventFormatter::DEFAULT,
+                "count" => 1,
+                "name" => "process.abstract",
+                "title" => ""
+              )
+            ]
+          )
+        end
+
+        it "completes the transaction" do
+          make_request(env)
+          expect(last_transaction).to be_completed
+        end
+      end
+
+      context "with an exception" do
+        let(:error) { ExampleException.new("error message") }
+        before do
+          allow(app).to receive(:call).and_raise(error)
+          expect { make_request_with_error(env, error) }
+            .to(change { created_transactions.count }.by(1))
+        end
+
+        it "creates a transaction for the request and records the exception" do
+          expect(last_transaction.to_h).to include(
+            "error" => hash_including(
+              "name" => "ExampleException",
+              "message" => "error message"
+            )
+          )
+        end
+
+        it "completes the transaction" do
+          expect(last_transaction).to be_completed
+        end
+      end
+
+      context "without action name metadata" do
+        it "reports no action name" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include("action" => nil)
+        end
+      end
+
+      context "with appsignal.route env" do
+        before do
+          env["appsignal.route"] = "POST /my-route"
+        end
+
+        it "reports the appsignal.route value as the action name" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include("action" => "POST /my-route")
+        end
+      end
+
+      context "with appsignal.action env" do
+        before do
+          env["appsignal.action"] = "POST /my-action"
+        end
+
+        it "reports the appsignal.route value as the action name" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include("action" => "POST /my-action")
+        end
+      end
+
+      describe "request metadata" do
+        before do
+          env.merge("PATH_INFO" => "/some/path", "REQUEST_METHOD" => "GET")
+        end
+
+        it "sets request metadata" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include(
+            "metadata" => {
+              "method" => "GET",
+              "path" => "/some/path"
+            },
+            "sample_data" => hash_including(
+              "environment" => hash_including(
+                "REQUEST_METHOD" => "GET",
+                "PATH_INFO" => "/some/path"
+                # and more, but we don't need to test Rack mock defaults
+              )
+            )
+          )
+        end
+
+        it "sets request parameters" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_including(
+              "params" => hash_including(
+                "page" => "2",
+                "query" => "lorem"
+              )
+            )
+          )
+        end
+      end
+
+      context "with queue start header" do
+        let(:queue_start_time) { fixed_time * 1_000 }
+        before do
+          env["HTTP_X_REQUEST_START"] = "t=#{queue_start_time.to_i}" # in milliseconds
+        end
+
+        it "sets the queue start" do
+          make_request(env)
+
+          expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+        end
+      end
+
+      class FilteredRequest
+        attr_reader :env
+
+        def initialize(env)
+          @env = env
+        end
+
+        def path
+          "/static/path"
+        end
+
+        def request_method
+          "GET"
+        end
+
+        def filtered_params
+          { "abc" => "123" }
+        end
+      end
+
+      context "with overridden request class and params method" do
+        let(:options) do
+          { :request_class => FilteredRequest, :params_method => :filtered_params }
+        end
+
+        it "uses the overridden request class and params method to fetch params" do
+          make_request(env)
+
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_including(
+              "params" => { "abc" => "123" }
+            )
+          )
+        end
+      end
+
+      context "with parent instrumentation" do
+        before do
+          env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = http_request_transaction
+        end
+
+        it "uses the existing transaction" do
+          make_request(env)
+
+          expect { make_request(env) }.to_not(change { created_transactions.count })
+        end
+
+        it "doesn't complete the existing transaction" do
+          make_request(env)
+
+          expect(env[Appsignal::Rack::APPSIGNAL_TRANSACTION]).to_not be_completed
+        end
+
+        context "with custom set action name" do
+          it "does not overwrite the action name" do
+            env[Appsignal::Rack::APPSIGNAL_TRANSACTION].set_action("My custom action")
+            env["appsignal.action"] = "POST /my-action"
+            make_request(env)
+
+            expect(last_transaction.to_h).to include("action" => "My custom action")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/appsignal/rack/event_handler_spec.rb

@@ -11,6 +11,7 @@ describe Appsignal::Rack::EventHandler do
   let(:response) { nil }
   let(:log_stream) { StringIO.new }
   let(:log) { log_contents(log_stream) }
+  let(:event_handler_instance) { described_class.new }
   before do
     start_agent
     Appsignal.internal_logger = test_logger(log_stream)
@@ -18,7 +19,7 @@ describe Appsignal::Rack::EventHandler do
   around { |example| keep_transactions { example.run } }
 
   def on_start
-    described_class.new.on_start(request, response)
+    event_handler_instance.on_start(request, response)
   end
 
   describe "#on_start" do
@@ -34,6 +35,14 @@ describe Appsignal::Rack::EventHandler do
       expect(Appsignal::Transaction.current).to eq(last_transaction)
     end
 
+    context "when the handler is nested in another EventHandler" do
+      it "does not create a new transaction in the nested EventHandler" do
+        on_start
+        expect { described_class.new.on_start(request, response) }
+          .to_not(change { created_transactions.length })
+      end
+    end
+
     it "registers transaction on the request environment" do
       on_start
 
@@ -87,7 +96,7 @@ describe Appsignal::Rack::EventHandler do
 
   describe "#on_error" do
     def on_error(error)
-      described_class.new.on_error(request, response, error)
+      event_handler_instance.on_error(request, response, error)
     end
 
     it "reports the error" do
@@ -103,6 +112,15 @@ describe Appsignal::Rack::EventHandler do
       )
     end
 
+    context "when the handler is nested in another EventHandler" do
+      it "does not report the error on the transaction" do
+        on_start
+        described_class.new.on_error(request, response, ExampleStandardError.new("the error"))
+
+        expect(last_transaction.to_h).to include("error" => nil)
+      end
+    end
+
     it "logs an error in case of an internal error" do
       on_start
 
@@ -122,7 +140,7 @@ describe Appsignal::Rack::EventHandler do
     let(:response) { Rack::Events::BufferedResponse.new(200, {}, ["body"]) }
 
     def on_finish
-      described_class.new.on_finish(request, response)
+      event_handler_instance.on_finish(request, response)
     end
 
     it "doesn't do anything without a transaction" do
@@ -155,6 +173,22 @@ describe Appsignal::Rack::EventHandler do
         )
       )
       expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+      expect(last_transaction).to be_completed
+    end
+
+    context "when the handler is nested in another EventHandler" do
+      it "does not complete the transaction" do
+        on_start
+        described_class.new.on_finish(request, response)
+
+        expect(last_transaction.to_h).to include(
+          "action" => nil,
+          "metadata" => {},
+          "sample_data" => {},
+          "events" => []
+        )
+        expect(last_transaction).to_not be_completed
+      end
     end
 
     it "doesn't set the action name if already set" do
@@ -183,6 +217,25 @@ describe Appsignal::Rack::EventHandler do
       )
     end
 
+    it "sets the response status as a tag" do
+      on_start
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "sample_data" => hash_including(
+          "tags" => { "response_status" => 200 }
+        )
+      )
+    end
+
+    it "increments the response status counter for response status" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with(:response_status, 1, :status => 200, :namespace => :web)
+
+      on_start
+      on_finish
+    end
+
     it "logs an error in case of an error" do
       expect(Appsignal::Transaction)
         .to receive(:complete_current!).and_raise(ExampleStandardError, "oh no")