posthog-rails 3.13.0 → 3.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbadf59825cbf2d519a1eab2aa36e56cba2bc9c395076857e50bc126e41300b0
-  data.tar.gz: de897b215980ee6bcbbfe54416073fed3d5b9321fce30443dacb015a7785b073
+  metadata.gz: bc1787c8bae17ac624fd59a956284a92e996082c0774a83e27cf8b7554ae5393
+  data.tar.gz: d13ef6ae2d87f8820050f4fd86e9588b09d5cfea1591548d9a70a0b0d38810d3
 SHA512:
-  metadata.gz: 33068f5f9b2673d0f9acf9f1acb20f50a8f99c04e1182911d9245c539e8d2566a3c42fb6da125d89853a7cadadf187754b3d49e24666a46d274800bc9badf82f
-  data.tar.gz: d94d7cff285e97a7769683f1349689b770d8ddb3610ceb0f21cf68067ca56b0fe2ffbb103f2c5720fd39270cc3d84f6c8fb9e9c4e39fb83e2fb65a8da35123c3
+  metadata.gz: 8cf28fe0b562b377d411bc259c3f72a8e0ea9a28051714f2fa933f8082c1a58e1fa1f24f58759413fb4d0f1ad83b684ba74930183836da1f5c3e3bacfe07842d
+  data.tar.gz: 897e312969d310aaf1559bd5e9c02f9684faaa755375dc2f1dc36759d35db7f1a8766981474ecb5c13e431cb1e0ed34d265e42762c41f54f2ce99ee169ec3313

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.13.0
+  version: 3.13.1
 platform: ruby
 authors:
 - PostHog