appsignal 3.12.1-java → 3.12.3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 444ef21c052b54cf0691be97d913fd6c3faa7e54219a570a6aae4117b7c83dea
-  data.tar.gz: '095b571b4b2bb8d2e8f413d10f75ec07be08306472b2182cba69d2e628305b72'
+  metadata.gz: 751ad4a4320323d8c24373ac2c5900f1c901145416e2445b8b6c445c9f9525c9
+  data.tar.gz: 71e823be2cdc7aa5cd3f92eb07819134d74d7d214d85bc18af76ba10526f9eb6
 SHA512:
-  metadata.gz: 28d506f968e386e6a195b9f30f9c0a10f7860105d88e120a021917fc6c8e57595eb4199778a6a57b5f2d058770f79125b36e8c0b6b9abd757027a397ec35791d
-  data.tar.gz: b60993c16502163d34dd7352a7636cea2fd4f7b572b241282d819be0e4a4d21dc739f52a615f2e4dd5ed28197b8873631b3288abfb29671fcd52b1f7cc2a6b3e
+  metadata.gz: 3fd78385cd1e814ed7f13f38d62ba25453d43fcea1cdd8778d94938dc056d0c7ffa8c8408ebc4abcc45271b47c306d25e81997a27c84b48a70d6b36827bb502d
+  data.tar.gz: f73268ac9b4101426569e81593cf25913cafeaac362493f52c4fe8325af8f1adfba4a4c7bfd6b3a5ca5e3c5c3f21f68cf15e7b3529eacdb7284ef895d18b1539

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.12.3
+
+_Published on 2024-07-30._
+
+### Fixed
+
+- Fix the application environment being reported as "[]" when no valid environment could be found. (patch [cf081253](https://github.com/appsignal/appsignal-ruby/commit/cf0812536e0651ee5b62427847a4244d4640e22b))
+- Fix `Appsignal.configure` call without `env` argument not reusing the previously configured configuration. (patch [65d5428c](https://github.com/appsignal/appsignal-ruby/commit/65d5428c4d41f683a796b67b0ae339a0d213c802))
+
+## 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,37 @@ 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
+
+      nil
+    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 +257,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 +275,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.3"
 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
 
@@ -244,12 +241,12 @@ module Appsignal
         return
       end
 
-      if config && config.env == env.to_s
+      if config && (env.nil? || 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,103 @@
 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
+
+      it "returns nil if no env was found" do
+        expect(described_class.determine_env).to be_nil
+      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 +222,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

@@ -61,6 +61,28 @@ describe Appsignal do
     end
 
     context "with config but not started" do
+      it "reuses the already loaded config if no env arg is given" do
+        Appsignal._config = Appsignal::Config.new(
+          project_fixture_path,
+          :my_env,
+          :ignore_actions => ["My action"]
+        )
+
+        Appsignal.configure do |config|
+          expect(config.env).to eq("my_env")
+          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[:name]).to eq("My app")
+        expect(Appsignal.config[:push_api_key]).to eq("key")
+        expect(Appsignal.config[:ignore_actions]).to eq(["My action"])
+      end
+
       it "reuses the already loaded config if the env is the same" do
         Appsignal._config = Appsignal::Config.new(
           project_fixture_path,
@@ -209,6 +231,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 +319,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.3
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-25 00:00:00.000000000 Z
+date: 2024-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack