appsignal 3.11.0 → 3.12.0

data/spec/lib/appsignal/probes_spec.rb

@@ -408,13 +408,14 @@ describe Appsignal::Probes do
       end
 
       context "logger" do
-        let(:log_stream) { std_stream }
-        let(:log) { log_contents(log_stream) }
+        before { start_agent }
 
-        around { |example| use_logger_with(log_stream) { example.run } }
         it "logs a deprecation message" do
-          silence { collection.register :my_probe, lambda {} }
-          expect(log).to contains_log :warn,
+          logs =
+            capture_logs do
+              silence { collection.register :my_probe, lambda {} }
+            end
+          expect(logs).to contains_log :warn,
             "The method 'Appsignal::Probes.probes.register' is deprecated. " \
               "Use 'Appsignal::Probes.register' instead."
         end

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

@@ -12,7 +12,7 @@ describe Appsignal::Rack::AbstractMiddleware do
   let(:options) { {} }
   let(:middleware) { described_class.new(app, options) }
 
-  before(:context) { start_agent }
+  before { start_agent }
   around { |example| keep_transactions { example.run } }
 
   def make_request
@@ -400,11 +400,12 @@ describe Appsignal::Rack::AbstractMiddleware do
           expect(response_events).to eq(1)
         end
 
-        context "when response body is already a BodyWrapper subclass" do
+        context "when the response body is already instrumented" do
           let(:body) { Appsignal::Rack::BodyWrapper.wrap(["hello!"], transaction) }
           let(:app) { DummyApp.new { [200, {}, body] } }
 
           it "doesn't wrap the body again" do
+            env[Appsignal::Rack::APPSIGNAL_RESPONSE_INSTRUMENTED] = true
             _status, _headers, body = make_request
             expect(body).to eq(body)
 

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

@@ -40,6 +40,14 @@ describe Appsignal::Rack::EventHandler do
       expect(Appsignal::Transaction.current).to eq(transaction)
     end
 
+    context "when not active" do
+      it "does not create a new transaction" do
+        allow(Appsignal).to receive(:active?).and_return(false)
+
+        expect { on_start }.to_not(change { created_transactions.length })
+      end
+    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
@@ -131,6 +139,17 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction).to have_error("ExampleStandardError", "the error")
     end
 
+    context "when not active" do
+      it "does not report the transaction" do
+        allow(Appsignal).to receive(:active?).and_return(false)
+
+        on_start
+        on_error(ExampleStandardError.new("the error"))
+
+        expect(last_transaction).to_not have_error
+      end
+    end
+
     context "when the handler is nested in another EventHandler" do
       it "does not report the error on the transaction" do
         on_start
@@ -175,6 +194,20 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction).to_not be_completed
     end
 
+    context "when not active" do
+      it "doesn't do anything" do
+        allow(Appsignal).to receive(:active?).and_return(false)
+
+        request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = http_request_transaction
+        on_finish
+
+        expect(last_transaction).to_not have_action
+        expect(last_transaction).to_not include_events
+        expect(last_transaction).to include("sample_data" => {})
+        expect(last_transaction).to_not be_completed
+      end
+    end
+
     it "sets params on the transaction" do
       on_start
       on_finish

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

@@ -46,7 +46,7 @@ describe "Appsignal::Rack::GenericInstrumentation" do
     let(:env) { Rack::MockRequest.env_for("/some/path") }
     let(:middleware) { Appsignal::Rack::GenericInstrumentation.new(app, {}) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around { |example| keep_transactions { example.run } }
 
     def make_request(env)

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

@@ -1,38 +1,5 @@
 if DependencyHelper.grape_present?
-  require "appsignal/integrations/grape"
-
-  context "Appsignal::Grape::Middleware constant" do
-    let(:err_stream) { std_stream }
-    let(:stderr) { err_stream.read }
-
-    it "returns the Rack::GrapeMiddleware constant calling the Grape::Middleware constant" do
-      silence { expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware) }
-    end
-
-    it "prints a deprecation warning to STDERR" do
-      capture_std_streams(std_stream, err_stream) do
-        expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware)
-      end
-
-      expect(stderr).to include(
-        "appsignal WARNING: The constant Appsignal::Grape::Middleware has been deprecated."
-      )
-    end
-
-    it "logs a warning" do
-      logs =
-        capture_logs do
-          silence do
-            expect(Appsignal::Grape::Middleware).to be(Appsignal::Rack::GrapeMiddleware)
-          end
-        end
-
-      expect(logs).to contains_log(
-        :warn,
-        "The constant Appsignal::Grape::Middleware has been deprecated."
-      )
-    end
-  end
+  require "appsignal/rack/grape_middleware"
 
   describe Appsignal::Rack::GrapeMiddleware do
     let(:app) do
@@ -52,7 +19,7 @@ if DependencyHelper.grape_present?
     end
     let(:middleware) { Appsignal::Rack::GrapeMiddleware.new(api_endpoint) }
     let(:transaction) { http_request_transaction }
-    before(:context) { start_agent }
+    before { start_agent }
     around do |example|
       GrapeExample = Module.new
       GrapeExample.send(:const_set, :Api, app)

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

@@ -12,7 +12,7 @@ if DependencyHelper.hanami2_present?
     end
     let(:middleware) { Appsignal::Rack::HanamiMiddleware.new(app, {}) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around { |example| keep_transactions { example.run } }
 
     def make_request(env)

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

@@ -1,5 +1,5 @@
 if DependencyHelper.sinatra_present?
-  require "appsignal/integrations/sinatra"
+  require "appsignal/rack/sinatra_instrumentation"
 
   module SinatraRequestHelpers
     def make_request
@@ -21,7 +21,7 @@ if DependencyHelper.sinatra_present?
     end
     let(:middleware) { Appsignal::Rack::SinatraInstrumentation.new(app) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around do |example|
       keep_transactions { example.run }
     end
@@ -54,7 +54,7 @@ if DependencyHelper.sinatra_present?
     let(:options) { {} }
     let(:middleware) { Appsignal::Rack::SinatraBaseInstrumentation.new(app, options) }
 
-    before(:context) { start_agent }
+    before { start_agent }
     around do |example|
       keep_transactions { example.run }
     end

data/spec/lib/appsignal/span_spec.rb

@@ -1,9 +1,7 @@
 require "appsignal/span"
 
 describe Appsignal::Span do
-  before :context do
-    start_agent
-  end
+  before { start_agent }
 
   let(:namespace) { "web" }
   let(:root) { Appsignal::Span.new(namespace) }

data/spec/lib/appsignal/transaction_spec.rb

@@ -1,10 +1,12 @@
 describe Appsignal::Transaction do
   let(:time) { Time.at(fixed_time) }
 
-  before { Timecop.freeze(time) }
+  before do
+    start_agent
+    Timecop.freeze(time)
+  end
   after { Timecop.return }
   around do |example|
-    start_agent
     keep_transactions do
       example.run
     end

data/spec/lib/appsignal_spec.rb

@@ -2,22 +2,226 @@ describe Appsignal do
   include EnvironmentMetadataHelper
   around { |example| keep_transactions { example.run } }
 
-  before do
-    # Make sure we have a clean state because we want to test
-    # initialization here.
-    Appsignal.config = nil
-  end
-
   let(:transaction) { http_request_transaction }
 
   describe ".config=" do
-    it "should set the config" do
+    it "sets the config" do
       config = project_fixture_config
       expect(Appsignal.internal_logger).to_not receive(:level=)
 
-      Appsignal.config = config
+      silence { Appsignal.config = config }
       expect(Appsignal.config).to eq config
     end
+
+    it "prints a deprecation warning" do
+      err_stream = std_stream
+      capture_std_streams(std_stream, err_stream) do
+        Appsignal.config = project_fixture_config
+      end
+      expect(err_stream.read).to include(
+        "appsignal WARNING: Configuring AppSignal with `Appsignal.config=` is deprecated."
+      )
+    end
+
+    it "logs a deprecation warning" do
+      logs = capture_logs { silence { Appsignal.config = project_fixture_config } }
+      expect(logs).to contains_log(
+        :warn,
+        "Configuring AppSignal with `Appsignal.config=` is deprecated."
+      )
+    end
+  end
+
+  describe ".configure" do
+    context "when active" do
+      it "doesn't update the config" do
+        start_agent
+        Appsignal::Testing.store[:config_called] = false
+        expect do
+          Appsignal.configure do |_config|
+            Appsignal::Testing.store[:config_called] = true
+          end
+        end.to_not(change { [Appsignal.config, Appsignal.active?] })
+        expect(Appsignal::Testing.store[:config_called]).to be(false)
+      end
+
+      it "logs a warning" do
+        start_agent
+        logs =
+          capture_logs do
+            Appsignal.configure do |_config|
+              # Do something
+            end
+          end
+        expect(logs).to contains_log(
+          :warn,
+          "AppSignal is already started. Ignoring `Appsignal.configure` call."
+        )
+      end
+    end
+
+    context "with config but not started" do
+      it "reuses the already loaded config if the env is the same" do
+        Appsignal._config = Appsignal::Config.new(
+          project_fixture_path,
+          :my_env,
+          :ignore_actions => ["My action"]
+        )
+
+        Appsignal.configure(:my_env) do |config|
+          expect(config.ignore_actions).to eq(["My action"])
+          config.active = true
+          config.name = "My app"
+          config.push_api_key = "key"
+        end
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("my_env")
+        expect(Appsignal.config[:active]).to be(true)
+        expect(Appsignal.config[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "loads a new config if the env is not the same" do
+        Appsignal._config = Appsignal::Config.new(
+          project_fixture_path,
+          :my_env,
+          :name => "Some name",
+          :push_api_key => "Some key",
+          :ignore_actions => ["My action"]
+        )
+
+        Appsignal.configure(:my_env2) do |config|
+          expect(config.ignore_actions).to be_empty
+          config.active = true
+          config.name = "My app"
+          config.push_api_key = "key"
+        end
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("my_env2")
+        expect(Appsignal.config[:active]).to be(true)
+        expect(Appsignal.config[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "calls configure if not started yet" do
+        Appsignal.configure(:my_env) do |config|
+          config.active = false
+          config.name = "Some name"
+        end
+        Appsignal.start
+        expect(Appsignal.started?).to be_falsy
+
+        Appsignal.configure(:my_env) do |config|
+          expect(config.ignore_actions).to be_empty
+          config.active = true
+          config.name = "My app"
+          config.push_api_key = "key"
+        end
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("my_env")
+        expect(Appsignal.config[:active]).to be(true)
+        expect(Appsignal.config[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+    end
+
+    context "when not active" do
+      it "starts with the configured config" do
+        Appsignal.configure(:test) do |config|
+          config.push_api_key = "key"
+        end
+
+        Appsignal.start
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "uses the given env" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        Appsignal.configure(:env_arg)
+
+        Appsignal.start
+        expect(Appsignal.config.env).to eq("env_arg")
+      end
+
+      it "loads the config without a block being given" do
+        Dir.chdir project_fixture_path do
+          Appsignal.configure(:test)
+        end
+
+        expect(Appsignal.config.env).to eq("test")
+        expect(Appsignal.config[:push_api_key]).to eq("abc")
+      end
+
+      it "allows customization of config in the block" do
+        Appsignal.configure(:test) do |config|
+          config.push_api_key = "key"
+        end
+
+        expect(Appsignal.config.valid?).to be(true)
+        expect(Appsignal.config.env).to eq("test")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+      end
+
+      it "loads the default config" do
+        Appsignal.configure do |config|
+          Appsignal::Config::DEFAULT_CONFIG.each do |option, value|
+            expect(config.send(option)).to eq(value)
+          end
+        end
+      end
+
+      it "loads the config from the YAML file" do
+        Dir.chdir project_fixture_path do
+          Appsignal.configure(:test) do |config|
+            expect(config.name).to eq("TestApp")
+          end
+        end
+      end
+
+      it "recognizes valid config" do
+        Appsignal.configure(:my_env) do |config|
+          config.push_api_key = "key"
+        end
+
+        expect(Appsignal.config.valid?).to be(true)
+      end
+
+      it "recognizes invalid config" do
+        Appsignal.configure(:my_env) do |config|
+          config.push_api_key = ""
+        end
+
+        expect(Appsignal.config.valid?).to be(false)
+      end
+
+      it "sets the environment when given as an argument" do
+        Appsignal.configure(:my_env)
+
+        expect(Appsignal.config.env).to eq("my_env")
+      end
+
+      it "reads the environment from the environment" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        Appsignal.configure do |config|
+          expect(config.env).to eq("env_env")
+        end
+
+        expect(Appsignal.config.env).to eq("env_env")
+      end
+
+      it "allows modification of previously unset config options" do
+        expect do
+          Appsignal.configure do |config|
+            config.ignore_actions << "My action"
+            config.request_headers << "My allowed header"
+          end
+        end.to_not(change { Appsignal::Config::DEFAULT_CONFIG })
+
+        expect(Appsignal.config[:ignore_actions]).to eq(["My action"])
+        expect(Appsignal.config[:request_headers])
+          .to eq(Appsignal::Config::DEFAULT_CONFIG[:request_headers] + ["My allowed header"])
+      end
+    end
   end
 
   describe ".start" do
@@ -50,7 +254,7 @@ describe Appsignal do
     end
 
     context "when config is loaded" do
-      before { Appsignal.config = project_fixture_config }
+      before { Appsignal._config = project_fixture_config }
 
       it "should initialize logging" do
         Appsignal.start
@@ -113,6 +317,27 @@ describe Appsignal do
         end
       end
 
+      describe "loaders" do
+        it "starts loaded loaders" do
+          Appsignal::Testing.store[:loader_loaded] = 0
+          Appsignal::Testing.store[:loader_started] = 0
+          define_loader(:start_loader) do
+            def on_load
+              Appsignal::Testing.store[:loader_loaded] += 1
+            end
+
+            def on_start
+              Appsignal::Testing.store[:loader_started] += 1
+            end
+          end
+          Appsignal::Loaders.load(:start_loader)
+          Appsignal::Loaders.start
+
+          expect(Appsignal::Testing.store[:loader_loaded]).to eq(1)
+          expect(Appsignal::Testing.store[:loader_started]).to eq(1)
+        end
+      end
+
       describe "environment metadata" do
         before { capture_environment_metadata_report_calls }
 
@@ -128,7 +353,7 @@ describe Appsignal do
     end
 
     context "with debug logging" do
-      before { Appsignal.config = project_fixture_config("test") }
+      before { Appsignal._config = project_fixture_config("test") }
 
       it "should change the log level" do
         Appsignal.start
@@ -137,6 +362,22 @@ describe Appsignal do
     end
   end
 
+  describe ".load" do
+    before do
+      TestLoader = define_loader(:appsignal_loader)
+    end
+    after do
+      Object.send(:remove_const, :TestLoader)
+    end
+
+    it "loads a loader" do
+      expect(Appsignal::Loaders.instances).to be_empty
+      Appsignal.load(:appsignal_loader)
+      expect(Appsignal::Loaders.instances)
+        .to include(:appsignal_loader => instance_of(TestLoader))
+    end
+  end
+
   describe ".forked" do
     context "when not active" do
       it "does nothing" do
@@ -148,7 +389,7 @@ describe Appsignal do
 
     context "when active" do
       before do
-        Appsignal.config = project_fixture_config
+        Appsignal._config = project_fixture_config
       end
 
       it "starts the logger and extension" do
@@ -162,7 +403,7 @@ describe Appsignal do
 
   describe ".stop" do
     it "calls stop on the extension" do
-      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping appsignal")
+      expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal")
       expect(Appsignal::Extension).to receive(:stop)
       Appsignal.stop
       expect(Appsignal.active?).to be_falsy
@@ -177,7 +418,7 @@ describe Appsignal do
 
     context "with context specified" do
       it "should log the context" do
-        expect(Appsignal.internal_logger).to receive(:debug).with("Stopping appsignal (something)")
+        expect(Appsignal.internal_logger).to receive(:debug).with("Stopping AppSignal (something)")
         expect(Appsignal::Extension).to receive(:stop)
         Appsignal.stop("something")
         expect(Appsignal.active?).to be_falsy
@@ -185,20 +426,34 @@ describe Appsignal do
     end
   end
 
-  describe ".active?" do
-    subject { Appsignal.active? }
+  describe ".started?" do
+    subject { Appsignal.started? }
 
-    context "without config" do
+    context "when started with active config" do
+      before { start_agent }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "when started with inactive config" do
       before do
-        Appsignal.config = nil
+        Appsignal._config = project_fixture_config("nonsense")
       end
 
       it { is_expected.to be_falsy }
     end
+  end
+
+  describe ".active?" do
+    subject { Appsignal.active? }
+
+    context "without config" do
+      it { is_expected.to be_falsy }
+    end
 
     context "with inactive config" do
       before do
-        Appsignal.config = project_fixture_config("nonsense")
+        Appsignal._config = project_fixture_config("nonsense")
       end
 
       it { is_expected.to be_falsy }
@@ -206,7 +461,7 @@ describe Appsignal do
 
     context "with active config" do
       before do
-        Appsignal.config = project_fixture_config
+        Appsignal._config = project_fixture_config
       end
 
       it { is_expected.to be_truthy }
@@ -232,7 +487,7 @@ describe Appsignal do
   end
 
   context "not active" do
-    before { Appsignal.config = project_fixture_config("not_active") }
+    before { Appsignal._config = project_fixture_config("not_active") }
 
     describe ".monitor_transaction" do
       it "does not create a transaction" do
@@ -883,13 +1138,11 @@ describe Appsignal do
     end
 
     describe ".add_breadcrumb" do
-      around do |example|
-        start_agent
-        with_current_transaction(transaction) { example.run }
-      end
+      before { start_agent }
 
       context "with transaction" do
         let(:transaction) { http_request_transaction }
+        before { set_current_transaction(transaction) }
 
         it "adds the breadcrumb to the transaction" do
           Appsignal.add_breadcrumb(
@@ -1648,7 +1901,7 @@ describe Appsignal do
     after { FileUtils.rm_rf(log_path) }
 
     def initialize_config
-      Appsignal.config = project_fixture_config(
+      Appsignal._config = project_fixture_config(
         "production",
         :log_path => log_path,
         :log_level => log_level
@@ -1795,7 +2048,6 @@ describe Appsignal do
 
       context "when there is no config" do
         before do
-          Appsignal.config = nil
           capture_stdout(out_stream) do
             Appsignal._start_logger
           end

data/spec/lib/puma/appsignal_spec.rb

@@ -76,9 +76,6 @@ RSpec.describe "Puma plugin" do
   let(:hostname) { Socket.gethostname }
   let(:expected_default_tags) { { "hostname" => hostname } }
   let(:stats_data) { { :backlog => 1 } }
-  before :context do
-    Appsignal.stop
-  end
   before do
     module Puma
       def self.stats

data/spec/spec_helper.rb

@@ -66,6 +66,7 @@ RSpec.configure do |config|
   config.include ApiRequestHelper
   config.include SystemHelpers
   config.include LogHelpers
+  config.include LoaderHelper
   config.extend DependencyHelper
 
   config.example_status_persistence_file_path = "spec/examples.txt"
@@ -92,6 +93,10 @@ RSpec.configure do |config|
   end
 
   config.before do
+    Appsignal.clear!
+    Appsignal::Testing.clear!
+    Appsignal::Loaders.clear!
+    clear_current_transaction!
     stop_minutely_probes
     ENV["RAILS_ENV"] ||= "test"
     ENV["RACK_ENV"] ||= "test"
@@ -157,15 +162,11 @@ RSpec.configure do |config|
   end
 
   config.after do
-    Appsignal::Testing.clear!
-    clear_current_transaction!
     stop_minutely_probes
   end
 
   config.after :context do
     FileUtils.rm_f(File.join(project_fixture_path, "log/appsignal.log"))
-    Appsignal.config = nil
-    Appsignal.internal_logger = nil
   end
 
   def stop_minutely_probes