posthog-rails 3.5.0 → 3.5.2

data/lib/posthog/rails/railtie.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module PostHog
+  module Rails
+    class Railtie < ::Rails::Railtie
+      # Add PostHog module methods for accessing Rails-specific client
+      initializer 'posthog.set_configs' do |_app|
+        PostHog.class_eval do
+          class << self
+            attr_accessor :client
+
+            # Methods explicitly delegated to the client
+            DELEGATED_METHODS = %i[
+              capture
+              capture_exception
+              identify
+              alias
+              group_identify
+              is_feature_enabled
+              get_feature_flag
+              get_all_flags
+            ].freeze
+
+            # Initialize PostHog client with a block configuration
+            def init(options = {})
+              # If block given, yield to configuration
+              if block_given?
+                config = PostHog::Rails::InitConfig.new(options)
+                yield config
+                options = config.to_client_options
+              end
+
+              # Create the PostHog client
+              @client = PostHog::Client.new(options)
+            end
+
+            # Define delegated methods using metaprogramming
+            DELEGATED_METHODS.each do |method_name|
+              define_method(method_name) do |*args, **kwargs, &block|
+                ensure_initialized!
+                client.public_send(method_name, *args, **kwargs, &block)
+              end
+            end
+
+            def initialized?
+              !@client.nil?
+            end
+
+            # Fallback for any client methods not explicitly defined
+            # rubocop:disable Lint/RedundantSafeNavigation
+            def method_missing(method_name, ...)
+              if client&.respond_to?(method_name)
+                ensure_initialized!
+                client.public_send(method_name, ...)
+              else
+                super
+              end
+            end
+
+            def respond_to_missing?(method_name, include_private = false)
+              client&.respond_to?(method_name) || super
+            end
+            # rubocop:enable Lint/RedundantSafeNavigation
+
+            private
+
+            def ensure_initialized!
+              return if initialized?
+
+              raise 'PostHog is not initialized. Call PostHog.init in an initializer.'
+            end
+          end
+        end
+      end
+
+      # Insert middleware for exception capturing
+      initializer 'posthog.insert_middlewares' do |app|
+        # Insert after DebugExceptions to catch rescued exceptions
+        insert_middleware_after(
+          app, ActionDispatch::DebugExceptions,
+          PostHog::Rails::RescuedExceptionInterceptor
+        )
+
+        # Insert after ShowExceptions to capture all exceptions
+        insert_middleware_after(
+          app, ActionDispatch::ShowExceptions,
+          PostHog::Rails::CaptureExceptions
+        )
+      end
+
+      # After initialization, set up remaining integrations
+      config.after_initialize do |_app|
+        # Hook into ActiveJob only if enabled
+        if PostHog::Rails.config&.auto_instrument_active_job
+          ActiveSupport.on_load(:active_job) do
+            prepend PostHog::Rails::ActiveJobExtensions
+          end
+        end
+
+        next unless PostHog.initialized?
+
+        # Register with Rails error reporter (Rails 7.0+)
+        register_error_subscriber if rails_version_above_7?
+      end
+
+      # Ensure PostHog shuts down gracefully (register only once)
+      config.after_initialize do
+        next if @posthog_at_exit_registered
+
+        @posthog_at_exit_registered = true
+        at_exit { PostHog.client&.shutdown if PostHog.initialized? }
+      end
+
+      def self.insert_middleware_after(app, target, middleware)
+        if app.config.middleware.include?(target)
+          app.config.middleware.insert_after(target, middleware)
+        else
+          # Fallback: append to stack if target middleware is missing (e.g., API-only apps)
+          app.config.middleware.use(middleware)
+        end
+      end
+
+      def self.register_error_subscriber
+        return unless PostHog::Rails.config&.auto_capture_exceptions
+
+        subscriber = PostHog::Rails::ErrorSubscriber.new
+        ::Rails.error.subscribe(subscriber)
+      rescue StandardError => e
+        PostHog::Logging.logger.warn("Failed to register error subscriber: #{e.message}")
+        PostHog::Logging.logger.warn("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
+      end
+
+      def self.rails_version_above_7?
+        ::Rails.version.to_f >= 7.0
+      end
+    end
+
+    # Configuration wrapper for the init block
+    class InitConfig
+      def initialize(base_options = {})
+        @base_options = base_options
+      end
+
+      # Core PostHog options
+      def api_key=(value)
+        @base_options[:api_key] = value
+      end
+
+      def personal_api_key=(value)
+        @base_options[:personal_api_key] = value
+      end
+
+      def host=(value)
+        @base_options[:host] = value
+      end
+
+      def max_queue_size=(value)
+        @base_options[:max_queue_size] = value
+      end
+
+      def test_mode=(value)
+        @base_options[:test_mode] = value
+      end
+
+      def on_error=(value)
+        @base_options[:on_error] = value
+      end
+
+      def feature_flags_polling_interval=(value)
+        @base_options[:feature_flags_polling_interval] = value
+      end
+
+      def feature_flag_request_timeout_seconds=(value)
+        @base_options[:feature_flag_request_timeout_seconds] = value
+      end
+
+      def before_send=(value)
+        @base_options[:before_send] = value
+      end
+
+      def to_client_options
+        @base_options
+      end
+    end
+  end
+end

data/lib/posthog/rails/rescued_exception_interceptor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module PostHog
+  module Rails
+    # Middleware that intercepts exceptions that are rescued by Rails
+    # This middleware runs before ShowExceptions and captures the exception
+    # so we can report it even if Rails rescues it
+    class RescuedExceptionInterceptor
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue StandardError => e
+        # Store the exception so CaptureExceptions middleware can report it
+        env['posthog.rescued_exception'] = e if should_intercept?
+        raise e
+      end
+
+      private
+
+      def should_intercept?
+        PostHog::Rails.config&.report_rescued_exceptions
+      end
+    end
+  end
+end

data/lib/posthog/rails.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'posthog/rails/configuration'
+require 'posthog/rails/capture_exceptions'
+require 'posthog/rails/rescued_exception_interceptor'
+require 'posthog/rails/active_job'
+require 'posthog/rails/error_subscriber'
+require 'posthog/rails/railtie'
+
+module PostHog
+  module Rails
+    VERSION = PostHog::VERSION
+
+    # Thread-local key for tracking web request context
+    IN_WEB_REQUEST_KEY = :posthog_in_web_request
+
+    class << self
+      def config
+        @config ||= Configuration.new
+      end
+
+      attr_writer :config
+
+      def configure
+        yield config if block_given?
+      end
+
+      # Mark that we're in a web request context
+      # CaptureExceptions middleware will handle exception capture
+      def enter_web_request
+        Thread.current[IN_WEB_REQUEST_KEY] = true
+      end
+
+      # Clear web request context (called at end of request)
+      def exit_web_request
+        Thread.current[IN_WEB_REQUEST_KEY] = false
+      end
+
+      # Check if we're currently in a web request context
+      # Used by ErrorSubscriber to avoid duplicate captures
+      def in_web_request?
+        Thread.current[IN_WEB_REQUEST_KEY] == true
+      end
+    end
+  end
+end

data/lib/posthog-rails.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+unless defined?(Rails)
+  raise LoadError, 'posthog-rails requires Rails. Use the posthog-ruby gem directly for non-Rails applications.'
+end
+
+# Load core PostHog Ruby SDK
+require 'posthog'
+
+# Load Rails integration
+require 'posthog/rails'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: posthog-rails
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.5.2
 platform: ruby
 authors:
 - PostHog
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -45,31 +44,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/posthog.rb
-- lib/posthog/backoff_policy.rb
-- lib/posthog/client.rb
-- lib/posthog/defaults.rb
-- lib/posthog/exception_capture.rb
-- lib/posthog/feature_flag.rb
-- lib/posthog/feature_flag_error.rb
-- lib/posthog/feature_flag_result.rb
-- lib/posthog/feature_flags.rb
-- lib/posthog/field_parser.rb
-- lib/posthog/logging.rb
-- lib/posthog/message_batch.rb
-- lib/posthog/noop_worker.rb
-- lib/posthog/response.rb
-- lib/posthog/send_feature_flags_options.rb
-- lib/posthog/send_worker.rb
-- lib/posthog/transport.rb
-- lib/posthog/utils.rb
-- lib/posthog/version.rb
+- lib/generators/posthog/install_generator.rb
+- lib/posthog-rails.rb
+- lib/posthog/rails.rb
+- lib/posthog/rails/active_job.rb
+- lib/posthog/rails/capture_exceptions.rb
+- lib/posthog/rails/configuration.rb
+- lib/posthog/rails/error_subscriber.rb
+- lib/posthog/rails/parameter_filter.rb
+- lib/posthog/rails/railtie.rb
+- lib/posthog/rails/rescued_exception_interceptor.rb
 homepage: https://github.com/PostHog/posthog-ruby
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -84,8 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: PostHog integration for Rails
 test_files: []

data/lib/posthog/backoff_policy.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'posthog/defaults'
-
-module PostHog
-  class BackoffPolicy
-    include PostHog::Defaults::BackoffPolicy
-
-    # @param [Hash] opts
-    # @option opts [Numeric] :min_timeout_ms The minimum backoff timeout
-    # @option opts [Numeric] :max_timeout_ms The maximum backoff timeout
-    # @option opts [Numeric] :multiplier The value to multiply the current
-    #   interval with for each retry attempt
-    # @option opts [Numeric] :randomization_factor The randomization factor
-    #   to use to create a range around the retry interval
-    def initialize(opts = {})
-      @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
-      @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
-      @multiplier = opts[:multiplier] || MULTIPLIER
-      @randomization_factor =
-        opts[:randomization_factor] || RANDOMIZATION_FACTOR
-
-      @attempts = 0
-    end
-
-    # @return [Numeric] the next backoff interval, in milliseconds.
-    def next_interval
-      interval = @min_timeout_ms * (@multiplier**@attempts)
-      interval = add_jitter(interval, @randomization_factor)
-
-      @attempts += 1
-
-      [interval, @max_timeout_ms].min
-    end
-
-    private
-
-    def add_jitter(base, randomization_factor)
-      random_number = rand
-      max_deviation = base * randomization_factor
-      deviation = random_number * max_deviation
-
-      random_number < 0.5 ? base - deviation : base + deviation
-    end
-  end
-end