appsignal 3.11.0 → 3.12.1

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

@@ -6,59 +6,121 @@ if DependencyHelper.rails_present?
 
     after { clear_rails_error_reporter! }
 
-    context "after initializing the app" do
-      it "should call initialize_appsignal" do
-        expect(Appsignal::Integrations::Railtie).to receive(:initialize_appsignal)
+    module RailtieHelper
+      def self.ensure_initialize!
+        return if @initialized
 
-        MyApp::Application.config.root = project_fixture_path
+        MyApp::Application.config.root = ConfigHelpers.project_fixture_path
         MyApp::Application.initialize!
+        @initialized = true
       end
     end
 
-    describe "#initialize_appsignal" do
-      let(:app) { MyApp::Application.new }
+    def expect_middleware_to_match(middleware, klass, args)
+      expect(middleware.klass).to eq(klass)
+      expect(middleware.args).to match(args)
+    end
 
-      describe ".internal_logger" do
-        before  { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-        subject { Appsignal.internal_logger }
+    describe "on Rails app initialize!" do
+      it "starts AppSignal by calling its hooks" do
+        expect(Appsignal::Integrations::Railtie).to receive(:on_load).and_call_original
+        expect(Appsignal::Integrations::Railtie).to receive(:after_initialize).and_call_original
 
-        it { is_expected.to be_a Logger }
+        RailtieHelper.ensure_initialize!
       end
+    end
 
-      describe ".config" do
-        let(:config) { Appsignal.config }
+    describe "initializer" do
+      let(:app) { MyApp::Application.new }
+      before do
+        RailtieHelper.ensure_initialize!
+        Appsignal.config = nil
+      end
 
-        describe "basic configuration" do
-          before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
+      def initialize_railtie(event)
+        MyApp::Application.config.root = project_fixture_path
+        case event
+        when :on_load
+          described_class.on_load(app)
+        when :after_initialize
+          described_class.after_initialize(app)
+        else
+          raise "Unsupported test event '#{event}'"
+        end
+      end
 
-          it { expect(config).to be_a(Appsignal::Config) }
+      shared_examples "integrates with Rails" do
+        it "starts AppSignal" do
+          initialize_railtie(event)
 
-          it "sets the root_path" do
-            expect(config.root_path).to eq Pathname.new(project_fixture_path)
-          end
+          expect(Appsignal.active?).to be_truthy
+        end
 
-          it "sets the detected environment" do
-            expect(config.env).to eq "test"
-          end
+        it "doesn't overwrite the config if a config is already present " do
+          Appsignal.config = Appsignal::Config.new(
+            Dir.pwd,
+            "my_env",
+            :some_config => "some value"
+          )
+          initialize_railtie(event)
 
-          it "loads the app name" do
-            expect(config[:name]).to eq "TestApp"
-          end
+          expect(Appsignal.config.env).to eq("my_env")
+          expect(Appsignal.config.root_path).to eq(Dir.pwd)
+          expect(Appsignal.config[:some_config]).to eq("some value")
+        end
 
-          it "sets the log_path based on the root_path" do
-            expect(config[:log_path]).to eq Pathname.new(File.join(project_fixture_path, "log"))
-          end
+        it "sets the detected environment" do
+          initialize_railtie(event)
+
+          expect(Appsignal.config.env).to eq("test")
         end
 
-        context "with APPSIGNAL_APP_ENV ENV var set" do
-          before do
-            ENV["APPSIGNAL_APP_ENV"] = "env_test"
-            Appsignal::Integrations::Railtie.initialize_appsignal(app)
-          end
+        it "uses the APPSIGNAL_APP_ENV environment variable value as the environment" do
+          ENV["APPSIGNAL_APP_ENV"] = "env_test"
+          initialize_railtie(event)
 
-          it "uses the environment variable value as the environment" do
-            expect(config.env).to eq "env_test"
-          end
+          expect(Appsignal.config.env).to eq "env_test"
+        end
+
+        it "sets the Rails app path as root_path" do
+          initialize_railtie(event)
+
+          expect(Appsignal.config.root_path).to eq(Pathname.new(project_fixture_path))
+        end
+
+        it "loads the Rails app name in the initial config" do
+          initialize_railtie(event)
+
+          expect(Appsignal.config.initial_config[:name]).to eq "MyApp"
+        end
+
+        it "loads the app name from the project's appsignal.yml file" do
+          initialize_railtie(event)
+
+          expect(Appsignal.config[:name]).to eq "TestApp"
+        end
+
+        it "sets the log_path based on the root_path" do
+          initialize_railtie(event)
+
+          expect(Appsignal.config[:log_path])
+            .to eq(Pathname.new(File.join(project_fixture_path, "log")))
+        end
+
+        it "adds the middleware" do
+          initialize_railtie(event)
+
+          middlewares = MyApp::Application.middleware
+          expect_middleware_to_match(
+            middlewares.find { |m| m.klass == ::Rack::Events },
+            ::Rack::Events,
+            [[instance_of(Appsignal::Rack::EventHandler)]]
+          )
+          expect_middleware_to_match(
+            middlewares.find { |m| m.klass == Appsignal::Rack::RailsInstrumentation },
+            Appsignal::Rack::RailsInstrumentation,
+            []
+          )
         end
 
         if Rails.respond_to?(:error)
@@ -82,7 +144,7 @@ if DependencyHelper.rails_present?
 
             context "when enable_rails_error_reporter is enabled" do
               it "subscribes to the error reporter" do
-                Appsignal::Integrations::Railtie.initialize_appsignal(app)
+                initialize_railtie(event)
 
                 expect(error_reporter.subscribers)
                   .to eq([Appsignal::Integrations::RailsErrorReporterSubscriber])
@@ -92,7 +154,7 @@ if DependencyHelper.rails_present?
             context "when enable_rails_error_reporter is disabled" do
               it "does not subscribe to the error reporter" do
                 ENV["APPSIGNAL_ENABLE_RAILS_ERROR_REPORTER"] = "false"
-                Appsignal::Integrations::Railtie.initialize_appsignal(app)
+                initialize_railtie(event)
 
                 expect(error_reporter.subscribers)
                   .to_not eq([Appsignal::Integrations::RailsErrorReporterSubscriber])
@@ -102,215 +164,237 @@ if DependencyHelper.rails_present?
         else
           context "when Rails does not listen to `error`" do
             it "does not error trying to subscribe to the error reporter" do
-              Appsignal::Integrations::Railtie.initialize_appsignal(app)
+              initialize_railtie(event)
             end
           end
         end
       end
 
-      describe ".initial_config" do
-        before { Appsignal::Integrations::Railtie.initialize_appsignal(app) }
-        let(:config) { Appsignal.config.initial_config }
+      describe ".on_load" do
+        let(:event) { :on_load }
 
-        it "returns the initial config" do
-          expect(config[:name]).to eq "MyApp"
+        context "when start_at == :on_load" do
+          include_examples "integrates with Rails"
         end
-      end
 
-      describe "Rails listener middleware" do
-        it "adds the Rails listener middleware" do
-          expect(app.middleware).to receive(:insert_after).with(
-            ActionDispatch::DebugExceptions,
-            Appsignal::Rack::RailsInstrumentation
-          )
-          Appsignal::Integrations::Railtie.initialize_appsignal(app)
+        context "when start_at == :after_initialize" do
+          it "does not start AppSignal" do
+            app.config.appsignal.start_at = :after_initialize
+            initialize_railtie(event)
+
+            expect(Appsignal.active?).to be_falsy
+            expect(Appsignal.config).to be_nil
+          end
         end
       end
 
-      if Rails.respond_to?(:error)
-        describe "Rails error reporter" do
-          before { start_agent }
-          around { |example| keep_transactions { example.run } }
+      describe ".after_initialize" do
+        let(:event) { :after_initialize }
 
-          context "when error is not handled (reraises the error)" do
-            it "does nothing" do
-              with_rails_error_reporter do
-                expect do
-                  Rails.error.record { raise ExampleStandardError, "error message" }
-                end.to raise_error(ExampleStandardError, "error message")
-              end
+        context "when start_at == :after_initialize" do
+          before do
+            app.config.appsignal.start_at = :after_initialize
+          end
+
+          include_examples "integrates with Rails"
+        end
+
+        context "when start_at == :on_load" do
+          it "does not start AppSignal" do
+            app.config.appsignal.start_at = :on_load
+            initialize_railtie(event)
 
-              expect(created_transactions).to be_empty
+            expect(Appsignal.active?).to be_falsy
+            expect(Appsignal.config).to be_nil
+          end
+        end
+      end
+    end
+
+    if Rails.respond_to?(:error)
+      describe "Rails error reporter" do
+        before { start_agent }
+        around { |example| keep_transactions { example.run } }
+
+        context "when error is not handled (reraises the error)" do
+          it "does nothing" do
+            with_rails_error_reporter do
+              expect do
+                Rails.error.record { raise ExampleStandardError, "error message" }
+              end.to raise_error(ExampleStandardError, "error message")
             end
+
+            expect(created_transactions).to be_empty
           end
+        end
 
-          context "when error is handled (not reraised)" do
-            context "when a transaction is active" do
-              it "duplicates the transaction namespace, action and tags" do
-                current_transaction = http_request_transaction
-                current_transaction.set_namespace "custom"
-                current_transaction.set_action "CustomAction"
-                current_transaction.set_tags(
-                  :duplicated_tag => "duplicated value"
-                )
-
-                with_rails_error_reporter do
-                  with_current_transaction current_transaction do
-                    Rails.error.handle { raise ExampleStandardError, "error message" }
-
-                    transaction = last_transaction
-                    expect(transaction).to have_namespace("custom")
-                    expect(transaction).to have_action("CustomAction")
-                    expect(transaction).to have_error("ExampleStandardError", "error message")
-                    expect(transaction).to include_tags(
-                      "duplicated_tag" => "duplicated value",
-                      "severity" => "warning"
-                    )
-                  end
-                end
-              end
+        context "when error is handled (not reraised)" do
+          context "when a transaction is active" do
+            it "duplicates the transaction namespace, action and tags" do
+              current_transaction = http_request_transaction
+              current_transaction.set_namespace "custom"
+              current_transaction.set_action "CustomAction"
+              current_transaction.set_tags(
+                :duplicated_tag => "duplicated value"
+              )
 
-              it "overwrites duplicated tags with tags from context" do
-                current_transaction = http_request_transaction
-                current_transaction.set_tags(:tag1 => "duplicated value")
-
-                with_rails_error_reporter do
-                  with_current_transaction current_transaction do
-                    given_context = { :tag1 => "value1", :tag2 => "value2" }
-                    Rails.error.handle(:context => given_context) { raise ExampleStandardError }
-
-                    expect(last_transaction).to include_tags(
-                      "tag1" => "value1",
-                      "tag2" => "value2",
-                      "severity" => "warning"
-                    )
-                  end
+              with_rails_error_reporter do
+                with_current_transaction current_transaction do
+                  Rails.error.handle { raise ExampleStandardError, "error message" }
+
+                  transaction = last_transaction
+                  expect(transaction).to have_namespace("custom")
+                  expect(transaction).to have_action("CustomAction")
+                  expect(transaction).to have_error("ExampleStandardError", "error message")
+                  expect(transaction).to include_tags(
+                    "duplicated_tag" => "duplicated value",
+                    "severity" => "warning"
+                  )
                 end
               end
+            end
 
-              it "sends tags stored in :appsignal -> :custom_data as custom data" do
-                current_transaction = http_request_transaction
-
-                with_rails_error_reporter do
-                  with_current_transaction current_transaction do
-                    given_context = {
-                      :appsignal => {
-                        :custom_data => {
-                          :array => [1, 2],
-                          :hash => { :one => 1, :two => 2 }
-                        }
-                      }
-                    }
-                    Rails.error.handle(:context => given_context) { raise ExampleStandardError }
-
-                    transaction = last_transaction
-                    expect(transaction).to include_custom_data(
-                      "array" => [1, 2],
-                      "hash" => { "one" => 1, "two" => 2 }
-                    )
-                  end
+            it "overwrites duplicated tags with tags from context" do
+              current_transaction = http_request_transaction
+              current_transaction.set_tags(:tag1 => "duplicated value")
+
+              with_rails_error_reporter do
+                with_current_transaction current_transaction do
+                  given_context = { :tag1 => "value1", :tag2 => "value2" }
+                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+
+                  expect(last_transaction).to include_tags(
+                    "tag1" => "value1",
+                    "tag2" => "value2",
+                    "severity" => "warning"
+                  )
                 end
               end
+            end
 
-              it "overwrites duplicated namespace and action with custom from context" do
-                current_transaction = http_request_transaction
-                current_transaction.set_namespace "custom"
-                current_transaction.set_action "CustomAction"
+            it "sends tags stored in :appsignal -> :custom_data as custom data" do
+              current_transaction = http_request_transaction
 
-                with_rails_error_reporter do
-                  with_current_transaction current_transaction do
-                    given_context = {
-                      :appsignal => { :namespace => "context", :action => "ContextAction" }
+              with_rails_error_reporter do
+                with_current_transaction current_transaction do
+                  given_context = {
+                    :appsignal => {
+                      :custom_data => {
+                        :array => [1, 2],
+                        :hash => { :one => 1, :two => 2 }
+                      }
                     }
-                    Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+                  }
+                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
 
-                    transaction = last_transaction
-                    expect(transaction).to have_namespace("context")
-                    expect(transaction).to have_action("ContextAction")
-                  end
+                  transaction = last_transaction
+                  expect(transaction).to include_custom_data(
+                    "array" => [1, 2],
+                    "hash" => { "one" => 1, "two" => 2 }
+                  )
                 end
               end
             end
 
-            context "when no transaction is active" do
-              class ExampleRailsRequestMock
-                def path
-                  "path"
-                end
+            it "overwrites duplicated namespace and action with custom from context" do
+              current_transaction = http_request_transaction
+              current_transaction.set_namespace "custom"
+              current_transaction.set_action "CustomAction"
 
-                def method
-                  "GET"
-                end
+              with_rails_error_reporter do
+                with_current_transaction current_transaction do
+                  given_context = {
+                    :appsignal => { :namespace => "context", :action => "ContextAction" }
+                  }
+                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
 
-                def filtered_parameters
-                  { :user_id => 123, :password => "[FILTERED]" }
+                  transaction = last_transaction
+                  expect(transaction).to have_namespace("context")
+                  expect(transaction).to have_action("ContextAction")
                 end
               end
+            end
+          end
 
-              class ExampleRailsControllerMock
-                def action_name
-                  "index"
-                end
+          context "when no transaction is active" do
+            class ExampleRailsRequestMock
+              def path
+                "path"
+              end
 
-                def request
-                  @request ||= ExampleRailsRequestMock.new
-                end
+              def method
+                "GET"
               end
 
-              class ExampleRailsJobMock
+              def filtered_parameters
+                { :user_id => 123, :password => "[FILTERED]" }
               end
+            end
 
-              class ExampleRailsMailerMock < ActionMailer::MailDeliveryJob
-                def arguments
-                  ["ExampleRailsMailerMock", "send_mail"]
-                end
+            class ExampleRailsControllerMock
+              def action_name
+                "index"
               end
 
-              before do
-                clear_current_transaction!
+              def request
+                @request ||= ExampleRailsRequestMock.new
               end
+            end
 
-              it "fetches the action, path and method from the controller in the context" do
-                # The controller key is set by Rails when raised in a controller
-                given_context = { :controller => ExampleRailsControllerMock.new }
-                with_rails_error_reporter do
-                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
-                end
+            class ExampleRailsJobMock
+            end
 
-                transaction = last_transaction
-                expect(transaction).to have_action("ExampleRailsControllerMock#index")
-                expect(transaction).to include_metadata("path" => "path", "method" => "GET")
-                expect(transaction).to include_params("user_id" => 123, "password" => "[FILTERED]")
+            class ExampleRailsMailerMock < ActionMailer::MailDeliveryJob
+              def arguments
+                ["ExampleRailsMailerMock", "send_mail"]
               end
+            end
 
-              it "sets no action if no execution context is present" do
-                # The controller key is set by Rails when raised in a controller
-                with_rails_error_reporter do
-                  Rails.error.handle { raise ExampleStandardError }
-                end
+            before do
+              clear_current_transaction!
+            end
 
-                expect(last_transaction).to_not have_action
+            it "fetches the action, path and method from the controller in the context" do
+              # The controller key is set by Rails when raised in a controller
+              given_context = { :controller => ExampleRailsControllerMock.new }
+              with_rails_error_reporter do
+                Rails.error.handle(:context => given_context) { raise ExampleStandardError }
               end
+
+              transaction = last_transaction
+              expect(transaction).to have_action("ExampleRailsControllerMock#index")
+              expect(transaction).to include_metadata("path" => "path", "method" => "GET")
+              expect(transaction).to include_params("user_id" => 123,
+                "password" => "[FILTERED]")
             end
 
-            it "sets the error context as tags" do
-              given_context = {
-                :controller => ExampleRailsControllerMock.new, # Not set as tag
-                :job => ExampleRailsJobMock.new, # Not set as tag
-                :appsignal => { :something => "not used" }, # Not set as tag
-                :tag1 => "value1",
-                :tag2 => "value2"
-              }
+            it "sets no action if no execution context is present" do
+              # The controller key is set by Rails when raised in a controller
               with_rails_error_reporter do
-                Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+                Rails.error.handle { raise ExampleStandardError }
               end
 
-              expect(last_transaction).to include_tags(
-                "tag1" => "value1",
-                "tag2" => "value2",
-                "severity" => "warning"
-              )
+              expect(last_transaction).to_not have_action
+            end
+          end
+
+          it "sets the error context as tags" do
+            given_context = {
+              :controller => ExampleRailsControllerMock.new, # Not set as tag
+              :job => ExampleRailsJobMock.new, # Not set as tag
+              :appsignal => { :something => "not used" }, # Not set as tag
+              :tag1 => "value1",
+              :tag2 => "value2"
+            }
+            with_rails_error_reporter do
+              Rails.error.handle(:context => given_context) { raise ExampleStandardError }
             end
+
+            expect(last_transaction).to include_tags(
+              "tag1" => "value1",
+              "tag2" => "value2",
+              "severity" => "warning"
+            )
           end
         end
       end

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

@@ -61,7 +61,7 @@ describe Appsignal::Integrations::ShoryukenMiddleware do
 
       context "with parameter filtering" do
         before do
-          Appsignal.config = project_fixture_config("production")
+          start_agent("production")
           Appsignal.config[:filter_parameters] = ["foo"]
         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
 
@@ -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")
@@ -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)