appsignal 3.13.0 → 4.0.0.beta.1

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

@@ -3,19 +3,9 @@ if DependencyHelper.rails_present?
 
   describe Appsignal::Integrations::Railtie do
     include RailsHelper
-
+    before { Appsignal.clear! }
     after { clear_rails_error_reporter! }
 
-    module RailtieHelper
-      def self.ensure_initialize!
-        return if @initialized
-
-        MyApp::Application.config.root = ConfigHelpers.project_fixture_path
-        MyApp::Application.initialize!
-        @initialized = true
-      end
-    end
-
     def expect_middleware_to_match(middleware, klass, args)
       expect(middleware.klass).to eq(klass)
       expect(middleware.args).to match(args)
@@ -26,23 +16,32 @@ if DependencyHelper.rails_present?
         expect(Appsignal::Integrations::Railtie).to receive(:on_load).and_call_original
         expect(Appsignal::Integrations::Railtie).to receive(:after_initialize).and_call_original
 
-        RailtieHelper.ensure_initialize!
+        if MyApp::Application.initialized?
+          run_appsignal_railtie
+        else
+          MyApp::Application.initialize!
+        end
       end
     end
 
     describe "initializer" do
       let(:app) { MyApp::Application.new }
       before do
-        RailtieHelper.ensure_initialize!
-        Appsignal.config = nil
+        # Make sure it's initialized at least once
+        MyApp::Application.initialize!
+        Appsignal.clear!
       end
 
       def initialize_railtie(event)
-        MyApp::Application.config.root = project_fixture_path
+        MyApp::Application.config.root = rails_project_fixture_path
         case event
         when :on_load
           described_class.on_load(app)
         when :after_initialize
+          # Must call both so no steps are missed
+          described_class.on_load(app)
+          described_class.after_initialize(app)
+        when :only_after_initialize
           described_class.after_initialize(app)
         else
           raise "Unsupported test event '#{event}'"
@@ -56,19 +55,6 @@ if DependencyHelper.rails_present?
           expect(Appsignal.active?).to be_truthy
         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)
-
-          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 detected environment" do
           initialize_railtie(event)
 
@@ -85,13 +71,17 @@ if DependencyHelper.rails_present?
         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))
+          expect(Appsignal.config.root_path).to eq(Pathname.new(rails_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"
+          rails_defaults = Appsignal::Config.loader_defaults
+            .find { |loader| loader[:name] == :rails }
+          expect(rails_defaults[:options][:name]).to eq("MyApp")
+          expect(rails_defaults[:options][:log_path])
+            .to eq(Pathname.new(File.join(rails_project_fixture_path, "log")))
         end
 
         it "loads the app name from the project's appsignal.yml file" do
@@ -104,7 +94,7 @@ if DependencyHelper.rails_present?
           initialize_railtie(event)
 
           expect(Appsignal.config[:log_path])
-            .to eq(Pathname.new(File.join(project_fixture_path, "log")))
+            .to eq(Pathname.new(File.join(rails_project_fixture_path, "log")))
         end
 
         it "adds the middleware" do
@@ -182,7 +172,7 @@ if DependencyHelper.rails_present?
             app.config.appsignal.start_at = :after_initialize
             initialize_railtie(event)
 
-            expect(Appsignal.active?).to be_falsy
+            expect(Appsignal.started?).to be_falsy
             expect(Appsignal.config).to be_nil
           end
         end
@@ -200,11 +190,16 @@ if DependencyHelper.rails_present?
         end
 
         context "when start_at == :on_load" do
+          before do
+            Appsignal.clear_started!
+            Appsignal.clear_config!
+          end
+
           it "does not start AppSignal" do
             app.config.appsignal.start_at = :on_load
-            initialize_railtie(event)
+            initialize_railtie(:only_after_initialize)
 
-            expect(Appsignal.active?).to be_falsy
+            expect(Appsignal.started?).to be_falsy
             expect(Appsignal.config).to be_nil
           end
         end
@@ -216,36 +211,84 @@ if DependencyHelper.rails_present?
         before { start_agent }
         around { |example| keep_transactions { example.run } }
 
-        context "when error is not handled (reraises the error)" do
-          it "does nothing" do
+        it "reports the error when the error is not handled (reraises the error)" do
+          with_rails_error_reporter do
+            expect do
+              Rails.error.record { raise ExampleStandardError, "error message" }
+            end.to raise_error(ExampleStandardError, "error message")
+          end
+
+          expect(last_transaction).to have_error("ExampleStandardError", "error message")
+        end
+
+        it "reports the error when the error is handled (not reraised)" do
+          with_rails_error_reporter do
+            Rails.error.handle { raise ExampleStandardError, "error message" }
+          end
+
+          expect(last_transaction).to have_error("ExampleStandardError", "error message")
+        end
+
+        context "when no transaction is active" do
+          it "reports the error on a new transaction" do
             with_rails_error_reporter do
               expect do
-                Rails.error.record { raise ExampleStandardError, "error message" }
-              end.to raise_error(ExampleStandardError, "error message")
-            end
+                Rails.error.handle { raise ExampleStandardError, "error message" }
+              end.to change { created_transactions.count }.by(1)
 
-            expect(created_transactions).to be_empty
+              transaction = last_transaction
+              expect(transaction).to have_namespace(Appsignal::Transaction::HTTP_REQUEST)
+              expect(transaction).to_not have_action
+              expect(transaction).to have_error("ExampleStandardError", "error message")
+            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
+        context "when a transaction is active" do
+          it "reports the error on the transaction when a transaction is active" do
+            current_transaction = http_request_transaction
+            current_transaction.set_namespace "custom"
+            current_transaction.set_action "CustomAction"
+            current_transaction.add_tags(:duplicated_tag => "duplicated value")
+
+            with_rails_error_reporter do
+              with_current_transaction current_transaction do
+                Rails.error.handle { raise ExampleStandardError, "error message" }
+                expect do
+                  current_transaction.complete
+                end.to_not(change { created_transactions.count })
+
+                transaction = current_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 the current transaction has an error" do
+            it "reports the error on a new transaction" do
               current_transaction = http_request_transaction
               current_transaction.set_namespace "custom"
               current_transaction.set_action "CustomAction"
-              current_transaction.set_tags(
-                :duplicated_tag => "duplicated value"
-              )
+              current_transaction.add_tags(:duplicated_tag => "duplicated value")
+              current_transaction.add_error(ExampleStandardError.new("error message"))
 
               with_rails_error_reporter do
                 with_current_transaction current_transaction do
-                  Rails.error.handle { raise ExampleStandardError, "error message" }
+                  Rails.error.handle { raise ExampleStandardError, "other message" }
+                  expect do
+                    current_transaction.complete
+                  end.to change { created_transactions.count }.by(1)
 
                   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 have_error("ExampleStandardError", "other message")
                   expect(transaction).to include_tags(
                     "duplicated_tag" => "duplicated value",
                     "severity" => "warning"
@@ -254,148 +297,127 @@ if DependencyHelper.rails_present?
               end
             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 "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
-              end
-            end
-
-            it "overwrites duplicated namespace and action with custom from context" do
+            it "reports the error on a new transaction with the given context" do
               current_transaction = http_request_transaction
               current_transaction.set_namespace "custom"
               current_transaction.set_action "CustomAction"
+              current_transaction.add_tags(:duplicated_tag => "duplicated value")
+              current_transaction.add_custom_data(:original => "custom value")
+              current_transaction.add_error(ExampleStandardError.new("error message"))
 
               with_rails_error_reporter do
                 with_current_transaction current_transaction do
                   given_context = {
-                    :appsignal => { :namespace => "context", :action => "ContextAction" }
+                    :appsignal => {
+                      :namespace => "context",
+                      :action => "ContextAction",
+                      :custom_data => { :context => "context data" }
+
+                    }
                   }
-                  Rails.error.handle(:context => given_context) { raise ExampleStandardError }
+                  Rails.error.handle(:context => given_context) do
+                    raise ExampleStandardError, "other message"
+                  end
+                  expect do
+                    current_transaction.complete
+                  end.to change { created_transactions.count }.by(1)
 
                   transaction = last_transaction
                   expect(transaction).to have_namespace("context")
                   expect(transaction).to have_action("ContextAction")
+                  expect(transaction).to have_error("ExampleStandardError", "other message")
+                  expect(transaction).to include_tags(
+                    "duplicated_tag" => "duplicated value",
+                    "severity" => "warning"
+                  )
+                  expect(transaction).to include_custom_data(
+                    "original" => "custom value",
+                    "context" => "context data"
+                  )
                 end
               end
             end
           end
 
-          context "when no transaction is active" do
-            class ExampleRailsRequestMock
-              def path
-                "path"
-              end
-
-              def method
-                "GET"
-              end
-
-              def filtered_parameters
-                { :user_id => 123, :password => "[FILTERED]" }
-              end
-            end
-
-            class ExampleRailsControllerMock
-              def action_name
-                "index"
-              end
+          it "overwrites duplicate tags with tags from context" do
+            current_transaction = http_request_transaction
+            current_transaction.add_tags(:tag1 => "duplicated value")
 
-              def request
-                @request ||= ExampleRailsRequestMock.new
-              end
-            end
-
-            class ExampleRailsJobMock
-            end
+            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 }
+                current_transaction.complete
 
-            class ExampleRailsMailerMock < ActionMailer::MailDeliveryJob
-              def arguments
-                ["ExampleRailsMailerMock", "send_mail"]
+                expect(current_transaction).to include_tags(
+                  "tag1" => "value1",
+                  "tag2" => "value2",
+                  "severity" => "warning"
+                )
               end
             end
+          end
 
-            before do
-              clear_current_transaction!
-            end
+          it "sets namespace, action and custom data with values from context" do
+            current_transaction = http_request_transaction
+            current_transaction.set_namespace "custom"
+            current_transaction.set_action "CustomAction"
 
-            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
+            with_rails_error_reporter do
+              with_current_transaction current_transaction do
+                given_context = {
+                  :appsignal => {
+                    :namespace => "context",
+                    :action => "ContextAction",
+                    :custom_data => { :data => "context data" }
+                  }
+                }
                 Rails.error.handle(:context => given_context) { raise ExampleStandardError }
-              end
+                current_transaction.complete
 
-              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]")
+                expect(current_transaction).to have_namespace("context")
+                expect(current_transaction).to have_action("ContextAction")
+                expect(current_transaction).to include_custom_data("data" => "context data")
+              end
             end
+          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
+        if DependencyHelper.rails7_1_present?
+          it "sets the namespace to 'runner' if the source is the Rails runner" do
+            expect do
               with_rails_error_reporter do
-                Rails.error.handle { raise ExampleStandardError }
+                expect do
+                  Rails.error.record(:source => "application.runner.railties") do
+                    raise ExampleStandardError, "error message"
+                  end
+                end.to raise_error(ExampleStandardError, "error message")
               end
+            end.to change { created_transactions.count }.by(1)
 
-              expect(last_transaction).to_not have_action
-            end
+            transaction = last_transaction
+            expect(transaction).to have_namespace("runner")
+            expect(transaction).to_not have_action
+            expect(transaction).to have_error("ExampleStandardError", "error message")
+            expect(transaction).to include_tags("source" => "application.runner.railties")
           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"
-            )
+        it "sets the error context as tags" do
+          given_context = {
+            :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

@@ -9,7 +9,8 @@ describe Appsignal::Integrations::ShoryukenMiddleware do
   let(:queue) { "some-funky-queue-name" }
   let(:sqs_msg) { double(:message_id => "msg1", :attributes => {}) }
   let(:body) { {} }
-  before { start_agent }
+  let(:options) { {} }
+  before { start_agent(:options => options) }
   around { |example| keep_transactions { example.run } }
 
   def perform_shoryuken_job(&block)
@@ -60,10 +61,7 @@ describe Appsignal::Integrations::ShoryukenMiddleware do
       end
 
       context "with parameter filtering" do
-        before do
-          start_agent("production")
-          Appsignal.config[:filter_parameters] = ["foo"]
-        end
+        let(:options) { { :filter_parameters => ["foo"] } }
 
         it "filters selected arguments" do
           perform_shoryuken_job