action_reporter 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aabef092878a25b94f003857a4490ae941458a23f10a645f90967c2410f6abfd
-  data.tar.gz: 26e8cda7492641af36a02b4320a415fc1b1afabb530f7dcb06f475c8ece39d43
+  metadata.gz: 883155825258f4bf10900efaa4f5486fa651ddda415e21282ceba8063909fa1b
+  data.tar.gz: 7b2fe04f7a946503e516e744a9fa292b8002d6b75a30b69830f79ff272c26d7f
 SHA512:
-  metadata.gz: 490769c5999f15251385b654ec9a0e8e65b11b8f50e4f3c21d974b72bc3d2d8036852d9dfab8f108931b3809ddf9e9ef9dd7265bd88adc710febe91ef659c969
-  data.tar.gz: fbef1b1338b491ba88f792cb5dc1de0a218b4b7d914430ae3f607bfaccd7bd3cb0eb1d2b2694a80c2417b75748a91043d34efc2a034b3944fefd640f37bfe63c
+  metadata.gz: a252069094c66d8c5bf87204101a426c5dec49496065ba18548ab00a0c304932fc247fd32c13e08c34cc276ef1b777937c5456b895b58b6e42235b753c41b557
+  data.tar.gz: 9e596e6be356fd140c3137b90952dd8c105907fd17aac78a3e8ec21586eaa074cb760477b9b17198fec246473f3d32cd8abe0eb4691a596562ef742deb847f25

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # CHANGELOG
 
+## 3.0.0 (2026-03-13)
+
+- BREAKING: Remove backward-compat reporter loading
+  - Remove `AVAILABLE_REPORTERS` constant
+  - Stop eager requiring built-in reporters at boot
+  - Built-in reporters are now loaded lazily through `ActionReporter.available_reporters`
+- Fix built-in reporter constant autoloading
+  - Add `autoload` mappings for built-in reporters (`RailsReporter`, `AuditedReporter`, `PaperTrailReporter`, `ActiveVersionReporter`, `SentryReporter`, `HoneybadgerReporter`, `ScoutApmReporter`)
+  - Fix `NameError: uninitialized constant ActionReporter::ActiveVersionReporter` when reporters are referenced directly from app initializers
+- Fix custom reporter lazy loading regression
+  - `PluginDiscovery.load_registered_reporter` now attempts `require` before constant lookup
+  - Registered reporters can now be loaded from `require_path` when class is not preloaded
+- Improve plugin discovery thread safety
+  - Synchronize `register` writes with discovery mutex
+  - Snapshot registered reporters under lock in `available_reporters` before iteration
+- Remove fragile loaded-feature detection
+  - Remove substring-based `$LOADED_FEATURES` matching that could produce false positives
+  - Rely on idempotent `require` behavior instead
+- Improve context transformation behavior
+  - `Utils.deep_transform_values` now recursively transforms all values, including objects nested directly inside arrays
+- Add configurable current-context storage adapter
+  - New `ActionReporter::Current.storage_adapter=` with `#[]` / `#[]=` contract
+  - New `ActionReporter::Current.reset_storage_adapter!`
+  - Storage resolution order: explicit `storage_adapter` -> `ActiveSupport::IsolatedExecutionState` -> `Thread.current`
+  - Enables fiber-aware request storage customization in non-Rails environments
+- Add regression coverage for lazy loading and storage behavior
+  - Add spec for loading registered reporter via `require_path` when class is not preloaded
+  - Add spec for transforming array-contained objects in deep context transform
+  - Add specs for `Current.storage_adapter` validation and precedence
+
 ## 2.0.2 (2026-03-13)
 
 - Add `ActiveVersionReporter` integration for the `active_version` gem

data/lib/action_reporter/current.rb

@@ -2,57 +2,96 @@ require_relative "error"
 
 module ActionReporter
   # Thread-safe storage for ActionReporter context attributes
-  # Uses Thread.current for maximum compatibility and thread safety
-  # Note: ActiveSupport::CurrentAttributes is request-scoped (not thread-scoped),
-  # so we use Thread.current for proper thread isolation
+  # Uses ActiveSupport::IsolatedExecutionState when available (fiber/request-aware),
+  # and falls back to Thread.current for non-Rails/non-ActiveSupport environments.
   class Current
+    STORAGE_PREFIX = :action_reporter
+
     class << self
+      attr_reader :storage_adapter
+
+      def storage_adapter=(adapter)
+        if adapter && (!adapter.respond_to?(:[]) || !adapter.respond_to?(:[]=))
+          raise ArgumentError, "storage_adapter must respond to #[] and #[]="
+        end
+
+        @storage_adapter = adapter
+      end
+
+      def reset_storage_adapter!
+        @storage_adapter = nil
+      end
+
       def current_user
-        Thread.current[:action_reporter_current_user]
+        read(:current_user)
       end
 
       def current_user=(user)
-        Thread.current[:action_reporter_current_user] = user
+        write(:current_user, user)
       end
 
       def current_request_uuid
-        Thread.current[:action_reporter_current_request_uuid]
+        read(:current_request_uuid)
       end
 
       def current_request_uuid=(uuid)
-        Thread.current[:action_reporter_current_request_uuid] = uuid
+        write(:current_request_uuid, uuid)
       end
 
       def current_remote_addr
-        Thread.current[:action_reporter_current_remote_addr]
+        read(:current_remote_addr)
       end
 
       def current_remote_addr=(addr)
-        Thread.current[:action_reporter_current_remote_addr] = addr
+        write(:current_remote_addr, addr)
       end
 
       def transaction_id
-        Thread.current[:action_reporter_transaction_id]
+        read(:transaction_id)
       end
 
       def transaction_id=(transaction_id)
-        Thread.current[:action_reporter_transaction_id] = transaction_id
+        write(:transaction_id, transaction_id)
       end
 
       def transaction_name
-        Thread.current[:action_reporter_transaction_name]
+        read(:transaction_name)
       end
 
       def transaction_name=(transaction_name)
-        Thread.current[:action_reporter_transaction_name] = transaction_name
+        write(:transaction_name, transaction_name)
       end
 
       def reset
-        Thread.current[:action_reporter_current_user] = nil
-        Thread.current[:action_reporter_current_request_uuid] = nil
-        Thread.current[:action_reporter_current_remote_addr] = nil
-        Thread.current[:action_reporter_transaction_id] = nil
-        Thread.current[:action_reporter_transaction_name] = nil
+        write(:current_user, nil)
+        write(:current_request_uuid, nil)
+        write(:current_remote_addr, nil)
+        write(:transaction_id, nil)
+        write(:transaction_name, nil)
+      end
+
+      private
+
+      def storage
+        return storage_adapter if storage_adapter
+
+        if defined?(ActiveSupport::IsolatedExecutionState)
+          ActiveSupport::IsolatedExecutionState
+        else
+          Thread.current
+        end
+      end
+
+      def key(name)
+        :"#{STORAGE_PREFIX}_#{name}"
+      end
+
+      def read(name)
+        storage[key(name)]
+      end
+
+      def write(name, value)
+        storage[key(name)] = value
       end
     end
   end

data/lib/action_reporter/plugin_discovery.rb

@@ -28,10 +28,12 @@ module ActionReporter
       # @param class_name [String] Fully qualified class name
       # @param require_path [String] Path to require (e.g., "action_reporter/custom_reporter")
       def register(name, class_name:, require_path:)
-        registered_reporters[name] = {
-          class_name: class_name,
-          require_path: require_path
-        }
+        discovery_lock.synchronize do
+          registered_reporters[name] = {
+            class_name: class_name,
+            require_path: require_path
+          }
+        end
       end
 
       # Discover reporters from the filesystem (lazy-loaded, cached)
@@ -66,7 +68,8 @@ module ActionReporter
         reporters = discover.dup
 
         # Add registered reporters (lazy-loaded)
-        registered_reporters.each_value do |config|
+        registered_configs = discovery_lock.synchronize { registered_reporters.values.dup }
+        registered_configs.each do |config|
           reporter_class = load_registered_reporter(config)
           reporters << reporter_class if reporter_class
         rescue => e
@@ -99,7 +102,15 @@ module ActionReporter
 
         full_class_name = "ActionReporter::#{class_name}"
 
-        # Check if class is already defined (files are pre-required at boot)
+        # Lazy load reporter file on discovery.
+        # Some callers (including tests) pass synthetic paths that do not exist.
+        begin
+          require file_path
+        rescue LoadError
+          # Ignore and continue with constant resolution.
+        end
+
+        # Check if class is defined after requiring.
         return nil unless Object.const_defined?(full_class_name)
 
         klass = Object.const_get(full_class_name)
@@ -109,30 +120,22 @@ module ActionReporter
       end
 
       def load_registered_reporter(config)
-        # Check if class is already defined (e.g., in tests or already loaded)
-        return nil unless Object.const_defined?(config[:class_name])
-
-        klass = Object.const_get(config[:class_name])
-        return nil unless klass < Base
-
-        # Only require if class is not already available and require_path is provided
-        # This allows classes defined inline (e.g., in tests) to work without requiring files
-        if config[:require_path] && !required?(config[:require_path])
+        # Try to load reporter file first; require is idempotent.
+        if config[:require_path]
           begin
             require config[:require_path]
           rescue LoadError => e
-            # If file doesn't exist but class is already defined, that's okay
-            # (e.g., class defined inline in tests or already loaded)
             warn "ActionReporter: Could not require #{config[:require_path]}: #{e.message}" if logger
-            # Continue - class might already be defined
           end
         end
 
-        klass
-      end
+        # Check if class is defined (e.g., file loaded, inline test class, or already loaded)
+        return nil unless Object.const_defined?(config[:class_name])
 
-      def required?(path)
-        $LOADED_FEATURES.any? { |feature| feature.include?(path) }
+        klass = Object.const_get(config[:class_name])
+        return nil unless klass < Base
+
+        klass
       end
 
       def logger

data/lib/action_reporter/utils.rb

@@ -2,17 +2,16 @@ module ActionReporter
   module Utils
     module_function
 
-    def deep_transform_values(hash, &block)
-      hash.each_with_object({}) do |(k, v), result|
-        value = if v.is_a?(Hash)
-          deep_transform_values(v, &block)
-        elsif v.is_a?(Array)
-          v.map { |e| e.is_a?(Hash) ? deep_transform_values(e, &block) : e }
-        else
-          v
+    def deep_transform_values(value, &block)
+      case value
+      when Hash
+        value.each_with_object({}) do |(k, v), result|
+          result[k] = deep_transform_values(v, &block)
         end
-
-        result[k] = block.call(value)
+      when Array
+        value.map { |element| deep_transform_values(element, &block) }
+      else
+        block.call(value)
       end
     end
   end

data/lib/action_reporter/version.rb

@@ -1,3 +1,3 @@
 module ActionReporter
-  VERSION = "2.0.2"
+  VERSION = "3.0.0"
 end

data/lib/action_reporter.rb

@@ -4,30 +4,16 @@ require "action_reporter/base"
 require "action_reporter/current"
 require "action_reporter/plugin_discovery"
 
-# Core reporters are still required for backward compatibility
-# But discovery mechanism allows for lazy loading and custom reporters
-require "action_reporter/rails_reporter"
-require "action_reporter/honeybadger_reporter"
-require "action_reporter/sentry_reporter"
-require "action_reporter/scout_apm_reporter"
-require "action_reporter/audited_reporter"
-require "action_reporter/paper_trail_reporter"
-require "action_reporter/active_version_reporter"
-
 module ActionReporter
-  module_function
+  autoload :RailsReporter, "action_reporter/rails_reporter"
+  autoload :AuditedReporter, "action_reporter/audited_reporter"
+  autoload :PaperTrailReporter, "action_reporter/paper_trail_reporter"
+  autoload :ActiveVersionReporter, "action_reporter/active_version_reporter"
+  autoload :SentryReporter, "action_reporter/sentry_reporter"
+  autoload :HoneybadgerReporter, "action_reporter/honeybadger_reporter"
+  autoload :ScoutApmReporter, "action_reporter/scout_apm_reporter"
 
-  # Legacy hardcoded list (maintained for backward compatibility)
-  # Use `available_reporters` for auto-discovered reporters
-  AVAILABLE_REPORTERS = [
-    ActionReporter::RailsReporter,
-    ActionReporter::HoneybadgerReporter,
-    ActionReporter::SentryReporter,
-    ActionReporter::ScoutApmReporter,
-    ActionReporter::AuditedReporter,
-    ActionReporter::PaperTrailReporter,
-    ActionReporter::ActiveVersionReporter
-  ].freeze
+  module_function
 
   # Get available reporters (auto-discovered + registered)
   # This is lazy-loaded and does not block application boot

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_reporter
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Andrei Makarov