appsignal 3.12.1 → 3.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46d05d1215b1e5df918af1f3977f72113560dc8f7eb96370990830f8679bc207
-  data.tar.gz: '095b571b4b2bb8d2e8f413d10f75ec07be08306472b2182cba69d2e628305b72'
+  metadata.gz: 6c3b3a593d57934c4d68cd4931ea948c5420ae2cc6e4fc43e482fab0df89165a
+  data.tar.gz: 0baf865761f51726ccc56b39ad9dabb7f5e0dbdb8be02ab9c1e4389b7d6595e1
 SHA512:
-  metadata.gz: 071c32621a02badd7ba7cc4c2ddfcaed0eb1a05e271114b0bbc083ff5e1c4c2898c305c39fe36f7cb5e8cc634410f311034f04b2b2317cce1c8ce4157f8cdef9
-  data.tar.gz: b60993c16502163d34dd7352a7636cea2fd4f7b572b241282d819be0e4a4d21dc739f52a615f2e4dd5ed28197b8873631b3288abfb29671fcd52b1f7cc2a6b3e
+  metadata.gz: 24e03e7a0255146b69fc04dbafb01f446d51f0ab2a72f3596b922b42f652a344b12171a6bc8d94e00d91da666fa40f4fa5820996c1fa2fe0651a23abd90a2cb4
+  data.tar.gz: 01b1507a66c700c640a5465f9ec15d2a0f8b5ea42f1ba246b8daa0a81816eaf0d04a37dcc13325686576ef2d47b3ee1d36488d0af3f8ee443c2905278d0bd9b6

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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._

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.12.1"
+  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_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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.12.1
+  version: 3.12.2
 platform: ruby
 authors:
 - Robert Beekman