appsignal 3.12.0 → 3.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2cfb956b5058ae48109ce92cc65f4158f472797f531579e63aeb8398cb73044
-  data.tar.gz: 34ba16eb3b7c3b464e10fb9a8533d3b230cfb73550f6a804599e02b96fb909f1
+  metadata.gz: 6c3b3a593d57934c4d68cd4931ea948c5420ae2cc6e4fc43e482fab0df89165a
+  data.tar.gz: 0baf865761f51726ccc56b39ad9dabb7f5e0dbdb8be02ab9c1e4389b7d6595e1
 SHA512:
-  metadata.gz: e374e9fc6cb686ec6297cb9f8025a6309f011dfc8fff3c22f32f8ddb9635e867dfd001e7058553a3f2d624bf68065e2efe2f69e73692d9b05195736992d6af63
-  data.tar.gz: e83be1622f1c5d86748bc3bb93912d79ac2dd66cb6bbe61106aee8965b3aced6c31bc5e25689f52bfa7cb01da9f10e50fb76c47de1934b93cb12b6db705bb661
+  metadata.gz: 24e03e7a0255146b69fc04dbafb01f446d51f0ab2a72f3596b922b42f652a344b12171a6bc8d94e00d91da666fa40f4fa5820996c1fa2fe0651a23abd90a2cb4
+  data.tar.gz: 01b1507a66c700c640a5465f9ec15d2a0f8b5ea42f1ba246b8daa0a81816eaf0d04a37dcc13325686576ef2d47b3ee1d36488d0af3f8ee443c2905278d0bd9b6

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.12.2
+
+_Published on 2024-07-25._
+
+### Fixed
+
+- Fix the default env and root path for the integrations using loader mechanism. If `APPSIGNAL_APP_ENV` is set when using `Appsignal.load(...)`, the AppSignal env set in `APPSIGNAL_APP_ENV` is now leading again. (patch [b2d1c7ee](https://github.com/appsignal/appsignal-ruby/commit/b2d1c7ee082e6865d9dc8d23ef060ecec9197a0e))
+
+## 3.12.1
+
+_Published on 2024-07-25._
+
+### Fixed
+
+- Fix `Appsignal.monitor_and_stop` block passing. It would error with a `LocalJumpError`. Thanks to @cwaider. (patch [150569ff](https://github.com/appsignal/appsignal-ruby/commit/150569ff49e54ab743ed3db16d109abcf5719e30))
+
 ## 3.12.0
 
 _Published on 2024-07-22._
@@ -28,11 +44,9 @@ _Published on 2024-07-22._
   ```ruby
   # config/initializers/appsignal.rb
 
-  Appsignal.config = Appsignal::Config.new(
-    Rails.root,
-    Rails.env,
-    :ignore_actions => ["My action"]
-  )
+  Appsignal.configure do |config|
+    config.ignore_actions = ["My action"]
+  end
   ```
 
   Be aware that when `start_at` is set to `after_initialize`, AppSignal will not track any errors that occur when the initializers are run and the app fails to start.

data/lib/appsignal/config.rb

@@ -20,6 +20,35 @@ module Appsignal
       loader_defaults << [name, options]
     end
 
+    # Determine which env AppSignal should initialize with.
+    # @api private
+    def self.determine_env(initial_env = nil)
+      [
+        initial_env,
+        ENV.fetch("APPSIGNAL_APP_ENV", nil),
+        ENV.fetch("RAILS_ENV", nil),
+        ENV.fetch("RACK_ENV", nil)
+      ].compact.each do |env|
+        return env if env
+      end
+
+      loader_defaults.reverse.each do |(_loader_name, loader_defaults)|
+        env = loader_defaults[:env]
+        return env if env
+      end
+    end
+
+    # Determine which root path AppSignal should initialize with.
+    # @api private
+    def self.determine_root_path
+      loader_defaults.reverse.each do |(_loader_name, loader_defaults)|
+        root_path = loader_defaults[:root_path]
+        return root_path if root_path
+      end
+
+      Dir.pwd
+    end
+
     # @api private
     DEFAULT_CONFIG = {
       :activejob_report_errors => "all",
@@ -226,7 +255,9 @@ module Appsignal
 
       return unless load_on_new
 
-      # Determine starting environment
+      # Always override environment if set via this env var.
+      # TODO: This is legacy behavior. In the `Appsignal.configure` method the
+      # env argument is leading.
       @env = ENV["APPSIGNAL_APP_ENV"] if ENV.key?("APPSIGNAL_APP_ENV")
       load_config
       validate
@@ -242,20 +273,7 @@ module Appsignal
       @system_config = detect_from_system
       merge(system_config)
 
-      # Set defaults from loaders in reverse order so the first register
-      # loader's defaults overwrite all others
-      self.class.loader_defaults.reverse.each do |(_loader_name, loader_defaults)|
-        defaults = loader_defaults.compact.dup
-        # Overwrite root path
-        loader_path = defaults.delete(:root_path)
-        @root_path = loader_path if loader_path
-        # Overwrite env
-        loader_env = defaults.delete(:env)
-        @env = loader_env.to_s if loader_env
-        # Merge with the config loaded so far
-        merge(defaults)
-      end
-
+      # Merge initial config
       merge(initial_config)
       # Track origin of env
       @initial_config[:env] = @initial_env.to_s

data/lib/appsignal/helpers/instrumentation.rb

@@ -154,8 +154,8 @@ module Appsignal
       # documentation.
       #
       # @see monitor
-      def monitor_and_stop(action:, namespace: nil)
-        monitor(:namespace => namespace, :action => action)
+      def monitor_and_stop(action:, namespace: nil, &block)
+        monitor(:namespace => namespace, :action => action, &block)
       ensure
         Appsignal.stop("monitor_and_stop")
       end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.12.0"
+  VERSION = "3.12.2"
 end

data/lib/appsignal.rb

@@ -121,10 +121,7 @@ module Appsignal
 
       internal_logger.debug("Loading AppSignal gem")
 
-      @config ||= Config.new(
-        Dir.pwd,
-        ENV["APPSIGNAL_APP_ENV"] || ENV["RAILS_ENV"] || ENV.fetch("RACK_ENV", nil)
-      )
+      @config ||= Config.new(Config.determine_root_path, Config.determine_env)
 
       _start_logger
 
@@ -247,9 +244,9 @@ module Appsignal
       if config && config.env == env.to_s
         config
       else
-        self._config = Appsignal::Config.new(
-          Dir.pwd,
-          env || ENV["APPSIGNAL_APP_ENV"] || ENV["RAILS_ENV"] || ENV.fetch("RACK_ENV", nil),
+        @config = Config.new(
+          Config.determine_root_path,
+          Config.determine_env(env),
           {},
           Appsignal.internal_logger,
           nil,

data/spec/lib/appsignal/config_spec.rb

@@ -1,4 +1,99 @@
 describe Appsignal::Config do
+  describe ".determine_env" do
+    context "with env argument" do
+      before { clear_integration_env_vars! }
+
+      it "considers the given env leading" do
+        expect(described_class.determine_env("given_env")).to eq("given_env")
+      end
+
+      it "considers the given env leading over APPSIGNAL_APP_ENV" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        expect(described_class.determine_env("given_env")).to eq("given_env")
+      end
+
+      it "considers the given env leading over other env vars" do
+        ENV["RAILS_ENV"] = "rails_env"
+        ENV["RACK_ENV"] = "rack_env"
+        expect(described_class.determine_env("given_env")).to eq("given_env")
+      end
+
+      it "considers the given env leading over loader defaults" do
+        define_loader(:env_loader) do
+          def on_load
+            register_config_defaults(:env => "loader_env")
+          end
+        end
+        load_loader(:env_loader)
+        expect(described_class.determine_env("given_env")).to eq("given_env")
+      end
+    end
+
+    context "without env argument" do
+      before { clear_integration_env_vars! }
+
+      it "considers the APPSIGNAL_APP_ENV leading" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        ENV["RAILS_ENV"] = "rails_env"
+        ENV["RACK_ENV"] = "rack_env"
+        expect(described_class.determine_env).to eq("env_env")
+      end
+
+      it "considers the RAILS_ENV leading over other env vars" do
+        ENV["RAILS_ENV"] = "rails_env"
+        ENV["RACK_ENV"] = "rack_env"
+        expect(described_class.determine_env).to eq("rails_env")
+      end
+
+      it "reads from the RACK_ENV env last" do
+        ENV["RACK_ENV"] = "rack_env"
+        expect(described_class.determine_env).to eq("rack_env")
+      end
+
+      it "falls back on the first loader env" do
+        define_loader(:env_loader1) do
+          def on_load
+            register_config_defaults(:env => "loader_env1")
+          end
+        end
+        load_loader(:env_loader1)
+
+        define_loader(:env_loader2) do
+          def on_load
+            register_config_defaults(:env => "loader_env2")
+          end
+        end
+        load_loader(:env_loader2)
+
+        expect(described_class.determine_env).to eq("loader_env2")
+      end
+    end
+  end
+
+  describe ".determine_root_path" do
+    it "reads the root path from the first loader if any" do
+      define_loader(:path_loader1) do
+        def on_load
+          register_config_defaults(:root_path => "/loader_path1")
+        end
+      end
+      load_loader(:path_loader1)
+
+      define_loader(:path_loader2) do
+        def on_load
+          register_config_defaults(:root_path => "/loader_path2")
+        end
+      end
+      load_loader(:path_loader2)
+
+      expect(described_class.determine_root_path).to eq("/loader_path2")
+    end
+
+    it "falls back on the current working directory" do
+      expect(described_class.determine_root_path).to eq(Dir.pwd)
+    end
+  end
+
   describe "#initialize" do
     describe "environment" do
       context "when environment is nil" do
@@ -123,76 +218,6 @@ describe Appsignal::Config do
     end
   end
 
-  describe "loader default config" do
-    let(:config) do
-      described_class.new("some-path", "production")
-    end
-    before do
-      class TestLoader < Appsignal::Loaders::Loader
-        register :test
-        def on_load
-          register_config_defaults(
-            :env => "new_env",
-            :root_path => "/some/path",
-            :my_option => "my_value",
-            :nil_option => nil
-          )
-        end
-      end
-      load_loader(:test)
-    end
-    after do
-      Object.send(:remove_const, :TestLoader)
-      unregister_loader(:first)
-    end
-
-    it "merges with the loader defaults" do
-      expect(config.config_hash).to include(:my_option => "my_value")
-    end
-
-    it "does not set any nil values" do
-      expect(config.config_hash).to_not have_key(:nil_option)
-    end
-
-    it "overwrites the env" do
-      expect(config.env).to eq("new_env")
-    end
-
-    it "overwrites the path" do
-      expect(config.root_path).to eq("/some/path")
-    end
-
-    context "with multiple loaders" do
-      before do
-        class SecondLoader < Appsignal::Loaders::Loader
-          register :second
-          def on_load
-            register_config_defaults(
-              :env => "second_env",
-              :root_path => "/second/path",
-              :my_option => "second_value",
-              :second_option => "second_value"
-            )
-          end
-        end
-        load_loader(:second)
-      end
-      after do
-        Object.send(:remove_const, :SecondLoader)
-        unregister_loader(:second)
-      end
-
-      it "makes the first loader's config leading" do
-        expect(config.config_hash).to include(
-          :my_option => "my_value",
-          :second_option => "second_value"
-        )
-        expect(config.env).to eq("new_env")
-        expect(config.root_path).to eq("/some/path")
-      end
-    end
-  end
-
   describe "initial config" do
     let(:initial_config) do
       {

data/spec/lib/appsignal/transaction_spec.rb

@@ -1499,54 +1499,53 @@ describe Appsignal::Transaction do
   describe "#set_error" do
     let(:transaction) { new_transaction }
     let(:env) { http_request_env_with_data }
-    let(:error) do
-      e = ExampleStandardError.new("test message")
-      allow(e).to receive(:backtrace).and_return(["line 1"])
-      e
-    end
+    let(:error) { ExampleStandardError.new("test message") }
 
-    it "should also respond to add_exception for backwards compatibility" do
+    it "responds to add_exception for backwards compatibility" do
       expect(transaction).to respond_to(:add_exception)
     end
 
-    it "should not add the error if appsignal is not active" do
+    it "does not add the error if not active" do
       allow(Appsignal).to receive(:active?).and_return(false)
-      expect(transaction.ext).to_not receive(:set_error)
 
       transaction.set_error(error)
+
+      expect(transaction).to_not have_error
     end
 
-    context "when error is not an error" do
+    context "when error argument is not an error" do
       let(:error) { Object.new }
 
       it "does not add the error" do
-        expect(Appsignal.internal_logger).to receive(:error).with(
+        logs = capture_logs { transaction.set_error(error) }
+
+        expect(transaction).to_not have_error
+        expect(logs).to contains_log(
+          :error,
           "Appsignal::Transaction#set_error: Cannot set error. " \
             "The given value is not an exception: #{error.inspect}"
         )
-        expect(transaction.ext).to_not receive(:set_error)
-
-        transaction.set_error(error)
       end
     end
 
     context "for a http request" do
-      it "should set an error in the extension" do
-        expect(transaction.ext).to receive(:set_error).with(
+      it "sets an error on the transaction" do
+        allow(error).to receive(:backtrace).and_return(["line 1"])
+        transaction.set_error(error)
+
+        expect(transaction).to have_error(
           "ExampleStandardError",
           "test message",
-          Appsignal::Utils::Data.generate(["line 1"])
+          ["line 1"]
         )
-
-        transaction.set_error(error)
       end
     end
 
     context "when the error has no causes" do
-      it "should not send the causes information as sample data" do
-        expect(transaction.ext).to_not receive(:set_sample_data)
-
+      it "does not set the causes information as sample data" do
         transaction.set_error(error)
+
+        expect(transaction).to_not include_error_causes
       end
     end
 
@@ -1562,31 +1561,25 @@ describe Appsignal::Transaction do
       end
 
       it "sends the causes information as sample data" do
-        expect(transaction.ext).to receive(:set_error).with(
+        transaction.set_error(error)
+
+        expect(transaction).to have_error(
           "ExampleStandardError",
           "test message",
-          Appsignal::Utils::Data.generate(["line 1"])
+          ["line 1"]
         )
-
-        expect(transaction.ext).to receive(:set_sample_data).with(
-          "error_causes",
-          Appsignal::Utils::Data.generate(
-            [
-              {
-                :name => "RuntimeError",
-                :message => "cause message"
-              },
-              {
-                :name => "StandardError",
-                :message => "cause message 2"
-              }
-            ]
-          )
+        expect(transaction).to include_error_causes(
+          [
+            {
+              "name" => "RuntimeError",
+              "message" => "cause message"
+            },
+            {
+              "name" => "StandardError",
+              "message" => "cause message 2"
+            }
+          ]
         )
-
-        expect(Appsignal.internal_logger).to_not receive(:debug)
-
-        transaction.set_error(error)
       end
     end
 
@@ -1605,33 +1598,29 @@ describe Appsignal::Transaction do
       end
 
       it "sends only the first causes as sample data" do
-        expect(transaction.ext).to receive(:set_error).with(
-          "ExampleStandardError",
-          "wrapper error 10",
-          Appsignal::Utils::Data.generate(["line 1"])
-        )
-
-        expected_error_causes = Array.new(10) do |i|
-          {
-            :name => "ExampleStandardError",
-            :message => "wrapper error #{9 - i}"
-          }
-        end
+        expected_error_causes =
+          Array.new(10) do |i|
+            {
+              "name" => "ExampleStandardError",
+              "message" => "wrapper error #{9 - i}"
+            }
+          end
+        expected_error_causes.last["is_root_cause"] = false
 
-        expected_error_causes.last[:is_root_cause] = false
+        logs = capture_logs { transaction.set_error(error) }
 
-        expect(transaction.ext).to receive(:set_sample_data).with(
-          "error_causes",
-          Appsignal::Utils::Data.generate(expected_error_causes)
+        expect(transaction).to have_error(
+          "ExampleStandardError",
+          "wrapper error 10",
+          ["line 1"]
         )
-
-        expect(Appsignal.internal_logger).to receive(:debug).with(
+        expect(transaction).to include_error_causes(expected_error_causes)
+        expect(logs).to contains_log(
+          :debug,
           "Appsignal::Transaction#set_error: Error has more " \
             "than 10 error causes. Only the first 10 " \
             "will be reported."
         )
-
-        transaction.set_error(error)
       end
     end
 
@@ -1643,18 +1632,18 @@ describe Appsignal::Transaction do
         e
       end
 
-      it "should not raise an error" do
+      it "does not raise an error" do
         transaction.set_error(error)
       end
 
-      it "should set an error in the extension" do
-        expect(transaction.ext).to receive(:set_error).with(
+      it "sets an error on the transaction without an error message" do
+        transaction.set_error(error)
+
+        expect(transaction).to have_error(
           "ExampleStandardError",
           "",
-          Appsignal::Utils::Data.generate(["line 1"])
+          ["line 1"]
         )
-
-        transaction.set_error(error)
       end
     end
   end

data/spec/lib/appsignal_spec.rb

@@ -209,6 +209,52 @@ describe Appsignal do
         expect(Appsignal.config.env).to eq("env_env")
       end
 
+      it "reads the environment from a loader default" do
+        clear_integration_env_vars!
+        define_loader(:loader_env) do
+          def on_load
+            register_config_defaults(
+              :env => "loader_env"
+            )
+          end
+        end
+        load_loader(:loader_env)
+
+        Appsignal.configure do |config|
+          expect(config.env).to eq("loader_env")
+        end
+
+        expect(Appsignal.config.env).to eq("loader_env")
+      end
+
+      it "reads the root_path from a loader default" do
+        clear_integration_env_vars!
+        define_loader(:loader_path) do
+          def on_load
+            register_config_defaults(
+              :root_path => "/loader_path"
+            )
+          end
+        end
+        load_loader(:loader_path)
+
+        Appsignal.configure do |config|
+          expect(config.app_path).to eq("/loader_path")
+        end
+
+        expect(Appsignal.config.root_path).to eq("/loader_path")
+      end
+
+      it "considers the given env leading above APPSIGNAL_APP_ENV" do
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+
+        Appsignal.configure(:dsl_env) do |config|
+          expect(config.env).to eq("dsl_env")
+        end
+
+        expect(Appsignal.config.env).to eq("dsl_env")
+      end
+
       it "allows modification of previously unset config options" do
         expect do
           Appsignal.configure do |config|
@@ -251,6 +297,48 @@ describe Appsignal do
         expect(stderr).to_not include("[ERROR]")
         expect(stdout).to_not include("[ERROR]")
       end
+
+      it "reads the environment from the loader defaults" do
+        clear_integration_env_vars!
+        define_loader(:loader_env) do
+          def on_load
+            register_config_defaults(:env => "loader_env")
+          end
+        end
+        load_loader(:loader_env)
+
+        Appsignal.start
+
+        expect(Appsignal.config.env).to eq("loader_env")
+      end
+
+      it "reads the root_path from the loader defaults" do
+        define_loader(:loader_path) do
+          def on_load
+            register_config_defaults(:root_path => "/loader_path")
+          end
+        end
+        load_loader(:loader_path)
+
+        Appsignal.start
+
+        expect(Appsignal.config.root_path).to eq("/loader_path")
+      end
+
+      it "chooses APPSIGNAL_APP_ENV over the loader defaults as the default env" do
+        clear_integration_env_vars!
+        ENV["APPSIGNAL_APP_ENV"] = "env_env"
+        define_loader(:loader_env) do
+          def on_load
+            register_config_defaults(:env => "loader_env")
+          end
+        end
+        load_loader(:loader_env)
+
+        Appsignal.start
+
+        expect(Appsignal.config.env).to eq("env_env")
+      end
     end
 
     context "when config is loaded" do
@@ -745,6 +833,12 @@ describe Appsignal do
 
         expect(Appsignal).to have_received(:stop).with("monitor_and_stop")
       end
+
+      it "passes the block to Appsignal.monitor" do
+        expect do |blk|
+          Appsignal.monitor_and_stop(:action => "My action", &blk)
+        end.to yield_control
+      end
     end
 
     describe ".monitor_transaction" do

data/spec/support/helpers/config_helpers.rb

@@ -26,4 +26,10 @@ module ConfigHelpers
     Appsignal._config = project_fixture_config(env)
     Appsignal.start
   end
+
+  def clear_integration_env_vars!
+    ENV.delete("RAILS_ENV")
+    ENV.delete("RACK_ENV")
+    ENV.delete("PADRINO_ENV")
+  end
 end

data/spec/support/matchers/transaction.rb

@@ -59,6 +59,7 @@ define_transaction_sample_matcher_for(:environment)
 define_transaction_sample_matcher_for(:session_data)
 define_transaction_sample_matcher_for(:tags)
 define_transaction_sample_matcher_for(:custom_data)
+define_transaction_sample_matcher_for(:error_causes)
 
 RSpec::Matchers.define :be_completed do
   match(:notify_expectation_failures => true) do |transaction|
@@ -66,14 +67,14 @@ RSpec::Matchers.define :be_completed do
   end
 end
 
-RSpec::Matchers.define :have_error do |error_class, error_message|
+RSpec::Matchers.define :have_error do |error_class, error_message, error_backtrace|
   match(:notify_expectation_failures => true) do |transaction|
     transaction_error = transaction.to_h["error"]
     if error_class && error_message
       expect(transaction_error).to include(
         "name" => error_class,
         "message" => error_message,
-        "backtrace" => kind_of(String)
+        "backtrace" => error_backtrace ? JSON.dump(error_backtrace) : kind_of(String)
       )
     else
       expect(transaction_error).to be_any

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.12.0
+  version: 3.12.2
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-22 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack