posthog-rails 3.12.3 → 3.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 499457f4cdb3d65001ca2052dcce6231b7f56879333a5dd5c957376460a70992
-  data.tar.gz: e06c59907254de2d57373a167b20c21d5e54df9aca89b59bda2f138cd81e731b
+  metadata.gz: bc1787c8bae17ac624fd59a956284a92e996082c0774a83e27cf8b7554ae5393
+  data.tar.gz: d13ef6ae2d87f8820050f4fd86e9588b09d5cfea1591548d9a70a0b0d38810d3
 SHA512:
-  metadata.gz: 6c51cd064c094fc7df538a348a3faf842a873597e527eadb65e341850649beb09e18159d191b32bce744077ed54afa6c791479c74045ed018007cb647b666a05
-  data.tar.gz: c61468861d957d4a5cc41276fdae05ce4f00d621af51320dbb05c8f9571df28aa1d89524600f25ce71e2bfe1b9864678b5340583888e7682a9da7b1cc514a847
+  metadata.gz: 8cf28fe0b562b377d411bc259c3f72a8e0ea9a28051714f2fa933f8082c1a58e1fa1f24f58759413fb4d0f1ad83b684ba74930183836da1f5c3e3bacfe07842d
+  data.tar.gz: 897e312969d310aaf1559bd5e9c02f9684faaa755375dc2f1dc36759d35db7f1a8766981474ecb5c13e431cb1e0ed34d265e42762c41f54f2ce99ee169ec3313

data/lib/generators/posthog/templates/posthog.rb

@@ -37,6 +37,12 @@ PostHog::Rails.configure do |config|
   # making it easier to identify affected users and debug user-specific issues.
   # config.current_user_method = :current_user
 
+  # Or provide a resolver for apps that store user context outside controllers,
+  # such as ActiveSupport::CurrentAttributes. The resolver takes precedence over
+  # current_user_method and may accept the controller as an argument.
+  # config.current_user_resolver = proc { Current.user }
+  # config.current_user_resolver = proc { |controller| controller.current_user }
+
   # Additional exception classes to exclude from reporting
   # These are added to the default excluded exceptions
   # config.excluded_exceptions = [

data/lib/posthog/rails/capture_exceptions.rb

@@ -69,20 +69,40 @@ module PostHog
       def extract_distinct_id(env)
         # Prefer authenticated Rails user context. Request/tracing context is
         # applied later by the core capture path if this returns nil.
-        if PostHog::Rails.config&.capture_user_context && env['action_controller.instance']
-          controller = env['action_controller.instance']
-          method_name = PostHog::Rails.config&.current_user_method || :current_user
+        return nil unless PostHog::Rails.config&.capture_user_context
 
-          if controller.respond_to?(method_name, true)
-            user = controller.send(method_name)
-            user_id = extract_user_id(user) if user
-            return user_id if present?(user_id)
-          end
-        end
+        user = extract_current_user(env['action_controller.instance'])
+        user_id = extract_user_id(user) if user
+        return user_id if present?(user_id)
 
         nil
       end
 
+      def extract_current_user(controller)
+        resolver = PostHog::Rails.config&.current_user_resolver
+        return resolve_current_user(resolver, controller) if resolver
+
+        method_name = PostHog::Rails.config&.current_user_method || :current_user
+        return unless controller.respond_to?(method_name, true)
+
+        controller.send(method_name)
+      end
+
+      def resolve_current_user(resolver, controller)
+        call_current_user_resolver(resolver, controller)
+      rescue StandardError => e
+        PostHog::Logging.logger.warn("current_user_resolver failed: #{e.message}")
+        nil
+      end
+
+      def call_current_user_resolver(resolver, controller)
+        if resolver.arity.zero?
+          controller ? controller.instance_exec(&resolver) : resolver.call
+        elsif controller
+          resolver.call(controller)
+        end
+      end
+
       def extract_user_id(user)
         # Use configured method if specified
         method_name = PostHog::Rails.config&.user_id_method

data/lib/posthog/rails/configuration.rb

@@ -32,6 +32,10 @@ module PostHog
       # @return [Symbol] Method name to call on controller to get the current user. Defaults to :current_user.
       attr_accessor :current_user_method
 
+      # @return [Proc, nil] Callable used to resolve the current user. When set, this takes precedence over
+      #   current_user_method. The callable may accept the controller instance or no arguments.
+      attr_accessor :current_user_resolver
+
       # @return [Symbol, nil] Method name to call on the user object to get distinct_id. When nil, tries:
       #   posthog_distinct_id, distinct_id, id, pk, uuid in order.
       attr_accessor :user_id_method
@@ -68,6 +72,7 @@ module PostHog
         @use_tracing_headers = true
         @capture_user_context = true
         @current_user_method = :current_user
+        @current_user_resolver = nil
         @user_id_method = nil
         @logs_enabled = false
         @logs_forward_rails_logger = true

data/lib/posthog/rails/railtie.rb

@@ -64,24 +64,137 @@ module PostHog
         end
       end
 
+      MISSING_MIDDLEWARE_MESSAGE = 'No such middleware to insert'
+      MIDDLEWARE_FALLBACK_OPERATION = :posthog_insert_middleware_with_fallback
+
+      module MiddlewareStackFallback
+        def posthog_insert_middleware_with_fallback(location, target, middleware)
+          PostHog::Rails::Railtie.instance.send(
+            :insert_middleware_with_fallback,
+            self,
+            location,
+            target,
+            middleware
+          )
+        end
+
+        private :posthog_insert_middleware_with_fallback
+      end
+
+      private_constant :MISSING_MIDDLEWARE_MESSAGE,
+                       :MIDDLEWARE_FALLBACK_OPERATION,
+                       :MiddlewareStackFallback
+
       # @api private
       # @return [void]
       def insert_middleware_after(app, target, middleware)
-        # During initialization, app.config.middleware is a MiddlewareStackProxy
-        # which only supports recording operations (insert_after, use, etc.)
-        # and does NOT support query methods like include?.
-        app.config.middleware.insert_after(target, middleware)
+        insert_middleware(app.config.middleware, :after, target, middleware)
       end
 
       # @api private
       # @return [void]
       def insert_middleware_before(app, target, middleware)
-        # During initialization, app.config.middleware is a MiddlewareStackProxy
-        # which only supports recording operations (insert_before, use, etc.)
-        # and does NOT support query methods like include?.
-        app.config.middleware.insert_before(target, middleware)
+        insert_middleware(app.config.middleware, :before, target, middleware)
+      end
+
+      # During initialization, app.config.middleware is usually a
+      # Rails::Configuration::MiddlewareStackProxy. The proxy only records
+      # operations, so missing-target errors happen later when Rails builds the
+      # real ActionDispatch::MiddlewareStack. Add our own deferred operation so
+      # we can fall back at build time instead of crashing or silently skipping.
+      def insert_middleware(middleware_stack, location, target, middleware)
+        if middleware_stack_proxy?(middleware_stack)
+          append_middleware_operation(middleware_stack, location, target, middleware)
+        else
+          insert_middleware_with_fallback(middleware_stack, location, target, middleware)
+        end
       end
 
+      def middleware_stack_proxy?(middleware_stack)
+        defined?(::Rails::Configuration::MiddlewareStackProxy) &&
+          middleware_stack.instance_of?(::Rails::Configuration::MiddlewareStackProxy) &&
+          middleware_stack.instance_variable_defined?(:@operations)
+      end
+
+      def append_middleware_operation(middleware_stack, location, target, middleware)
+        operations = middleware_stack.instance_variable_get(:@operations)
+
+        if callable_middleware_operations?(middleware_stack, operations)
+          operations << lambda do |resolved_stack|
+            insert_middleware_with_fallback(resolved_stack, location, target, middleware)
+          end
+        else
+          ensure_middleware_stack_fallback_operation!
+          operations << [MIDDLEWARE_FALLBACK_OPERATION, [location, target, middleware], nil]
+        end
+      end
+
+      def callable_middleware_operations?(middleware_stack, operations)
+        operation = operations.first || probe_middleware_operation(middleware_stack)
+
+        operation.respond_to?(:call)
+      end
+
+      def probe_middleware_operation(middleware_stack)
+        probe = middleware_stack.class.new
+        probe.use(Object)
+        probe.instance_variable_get(:@operations).first
+      end
+
+      def ensure_middleware_stack_fallback_operation!
+        require 'action_dispatch/middleware/stack' unless defined?(::ActionDispatch::MiddlewareStack)
+        return if ::ActionDispatch::MiddlewareStack < MiddlewareStackFallback
+
+        ::ActionDispatch::MiddlewareStack.include(MiddlewareStackFallback)
+      end
+
+      def insert_middleware_with_fallback(middleware_stack, location, target, middleware)
+        perform_middleware_insert(middleware_stack, location, target, middleware)
+      rescue RuntimeError => e
+        raise unless missing_middleware_error?(e)
+
+        fallback_insert_middleware(middleware_stack, location, target, middleware)
+      end
+
+      def perform_middleware_insert(middleware_stack, location, target, middleware)
+        if location == :after
+          middleware_stack.insert_after(target, middleware)
+        else
+          middleware_stack.insert_before(target, middleware)
+        end
+      end
+
+      def fallback_insert_middleware(middleware_stack, location, target, middleware)
+        fallback_position = if location == :before && middleware_stack.respond_to?(:unshift)
+                              middleware_stack.unshift(middleware)
+                              'beginning'
+                            else
+                              middleware_stack.use(middleware)
+                              'end'
+                            end
+
+        PostHog::Logging.logger.warn(
+          "Could not find #{target.inspect} in the Rails middleware stack; " \
+          "inserted #{middleware.inspect} at the #{fallback_position} " \
+          'of the stack instead.'
+        )
+      end
+
+      def missing_middleware_error?(error)
+        error.message.start_with?(MISSING_MIDDLEWARE_MESSAGE)
+      end
+
+      private :insert_middleware,
+              :middleware_stack_proxy?,
+              :append_middleware_operation,
+              :callable_middleware_operations?,
+              :probe_middleware_operation,
+              :ensure_middleware_stack_fallback_operation!,
+              :insert_middleware_with_fallback,
+              :perform_middleware_insert,
+              :fallback_insert_middleware,
+              :missing_middleware_error?
+
       # Build the PostHog Logs pipeline and broadcast Rails.logger into it.
       #
       # @api private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: posthog-rails
 version: !ruby/object:Gem::Version
-  version: 3.12.3
+  version: 3.13.1
 platform: ruby
 authors:
 - PostHog
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3.13'
 description: Automatic exception tracking and instrumentation for Ruby on Rails applications
   using PostHog
 email: engineering@posthog.com