posthog-rails 3.8.1 → 3.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f7082d07840d3127b46409cfaa97b2d169cb0520d1589c9c5fdf7cf875a403b
-  data.tar.gz: 2371da2d51b6977fd8a2544270fae72c8c6e5e9465783ca9fd32bf118b85ae8c
+  metadata.gz: 792f6e0ca6b259928ec0704d585e4887fbd4839837b7d49c08fc47b7eeeeeaaf
+  data.tar.gz: bc72fab471755cd32695bfdc919aa5cc99559c626504af061e89b80ad98dfd33
 SHA512:
-  metadata.gz: 1eb75d92349a07684187e06367675d7e4a844f7c9fb04616e9c85a0c88e94f33a8adce88f092c1a476813523ebfb0b5ee317cb5013b17b9eb15b31209218fed1
-  data.tar.gz: '0338af574847d6c9f52e1c3f43b7f7b7401ee9966a1d0816d3b1a5967b3a4689d584e1801cfa50101e0106f4692239eb0ac2a9be5e7f7533099bca7266730705'
+  metadata.gz: f860543aeca28abfd50a110fa76fd2eed17a86e8c933cbbb0a0fdcdf4002d11bf400d2fb41d5680fa7587de749cad9514e71ad2a0855f1050827fb3da5d7a71b
+  data.tar.gz: afb7cb589db961516dea558424cdbe71ff9e20a004a0b944eba6f0aa54fdcb5a4be92acd0dfe6ce88abc84e35a63ca6567ecea4b5fd662018940b05b595aa27b

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

@@ -22,7 +22,13 @@ PostHog::Rails.configure do |config|
   # Set to true to enable automatic ActiveJob exception tracking
   # config.auto_instrument_active_job = true
 
-  # Capture user context with exceptions (default: true)
+  # Use PostHog tracing headers for request-scoped identity/session context (default: true)
+  # Request metadata (current URL, method, path, user agent, and IP) is always captured during Rails requests
+  # Set to false to ignore client-supplied X-PostHog-Distinct-Id and X-PostHog-Session-Id headers
+  # config.use_tracing_headers = true
+
+  # Capture authenticated user context with exceptions (default: true)
+  # Authenticated Rails user context takes precedence over client-supplied tracing headers for exception identity
   # config.capture_user_context = true
 
   # Controller method name to get current user (default: :current_user)

data/lib/posthog/rails/active_job.rb

@@ -13,7 +13,12 @@ module PostHog
       end
 
       module ClassMethods
-        # DSL for defining how to extract distinct_id from job arguments
+        # DSL for defining how to extract distinct_id from job arguments.
+        #
+        # @param proc [Proc, nil] Callable that receives the job's perform arguments.
+        # @yield The block receives the job's perform arguments.
+        # @return [Proc, nil] The configured extractor.
+        #
         # Example:
         #   class MyJob < ApplicationJob
         #     posthog_distinct_id ->(user, arg1, arg2) { user.id }
@@ -25,6 +30,7 @@ module PostHog
           @posthog_distinct_id_proc = proc || block
         end
 
+        # @return [Proc, nil] The configured distinct_id extractor.
         def posthog_distinct_id_proc
           @posthog_distinct_id_proc
         end

data/lib/posthog/rails/capture_exceptions.rb

@@ -4,20 +4,26 @@ require 'posthog/rails/parameter_filter'
 
 module PostHog
   module Rails
-    # Middleware that captures exceptions and sends them to PostHog
+    # Middleware that captures exceptions and sends them to PostHog.
+    #
+    # @api private
     class CaptureExceptions
       include ParameterFilter
 
+      # @param app [#call] Rack application.
       def initialize(app)
         @app = app
       end
 
+      # @param env [Hash] Rack environment.
+      # @return [Array] Rack response.
       def call(env)
         # Signal that we're in a web request context
         # ErrorSubscriber will skip capture for web requests to avoid duplicates
         PostHog::Rails.enter_web_request
 
         response = @app.call(env)
+        env['posthog.response_status_code'] = response_status(response)
 
         # Check if there was an exception that Rails handled
         exception = collect_exception(env)
@@ -51,7 +57,7 @@ module PostHog
 
       def capture_exception(exception, env)
         request = ActionDispatch::Request.new(env)
-        distinct_id = extract_distinct_id(env, request)
+        distinct_id = extract_distinct_id(env)
         additional_properties = build_properties(request, env)
 
         PostHog.capture_exception(exception, distinct_id, additional_properties)
@@ -60,20 +66,21 @@ module PostHog
         PostHog::Logging.logger.error("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
       end
 
-      def extract_distinct_id(env, request)
-        # Try to get user from controller if capture_user_context is enabled
+      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
 
           if controller.respond_to?(method_name, true)
             user = controller.send(method_name)
-            return extract_user_id(user) if user
+            user_id = extract_user_id(user) if user
+            return user_id if present?(user_id)
           end
         end
 
-        # Fallback to session ID or nil
-        request.session&.id&.to_s
+        nil
       end
 
       def extract_user_id(user)
@@ -98,10 +105,7 @@ module PostHog
 
       def build_properties(request, env)
         properties = {
-          '$exception_source' => 'rails',
-          '$current_url' => safe_serialize(request.url),
-          '$request_method' => safe_serialize(request.method),
-          '$request_path' => safe_serialize(request.path)
+          '$exception_source' => 'rails'
         }
 
         # Add controller and action if available
@@ -118,14 +122,23 @@ module PostHog
           properties['$request_params'] = safe_serialize(filtered_params) unless filtered_params.empty?
         end
 
-        # Add user agent
-        properties['$user_agent'] = safe_serialize(request.user_agent) if request.user_agent
+        response_status_code = env['posthog.response_status_code']
+        properties['$response_status_code'] = response_status_code if response_status_code
 
         # Add referrer
         properties['$referrer'] = safe_serialize(request.referrer) if request.referrer
 
         properties
       end
+
+      def response_status(response)
+        status = response.respond_to?(:[]) ? response[0] : nil
+        status if status.is_a?(Integer)
+      end
+
+      def present?(value)
+        !(value.nil? || (value.respond_to?(:empty?) && value.empty?))
+      end
     end
   end
 end

data/lib/posthog/rails/configuration.rb

@@ -3,39 +3,47 @@
 module PostHog
   module Rails
     class Configuration
-      # Whether to automatically capture exceptions from Rails
+      # @return [Boolean] Whether to automatically capture exceptions from Rails. Defaults to false.
       attr_accessor :auto_capture_exceptions
 
-      # Whether to capture exceptions that Rails rescues (e.g., with rescue_from)
+      # @return [Boolean] Whether to capture exceptions that Rails rescues (e.g., with rescue_from). Defaults to false.
       attr_accessor :report_rescued_exceptions
 
-      # Whether to automatically instrument ActiveJob
+      # @return [Boolean] Whether to automatically instrument ActiveJob. Defaults to false.
       attr_accessor :auto_instrument_active_job
 
-      # List of exception classes to ignore (in addition to default)
+      # @return [Array<String>] Exception class names to ignore in addition to the defaults.
       attr_accessor :excluded_exceptions
 
-      # Whether to capture the current user context in exceptions
+      # @return [Boolean] Whether to use PostHog tracing headers for request-scoped identity/session context.
+      #   Defaults to true.
+      attr_accessor :use_tracing_headers
+
+      # @return [Boolean] Whether to capture the current user context in exceptions. Defaults to true.
       attr_accessor :capture_user_context
 
-      # Method name to call on controller to get user ID (default: :current_user)
+      # @return [Symbol] Method name to call on controller to get the current user. Defaults to :current_user.
       attr_accessor :current_user_method
 
-      # Method name to call on user object to get distinct_id (default: auto-detect)
-      # When nil, tries: posthog_distinct_id, distinct_id, id, pk, uuid in order
+      # @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
 
+      # @return [PostHog::Rails::Configuration]
       def initialize
         @auto_capture_exceptions = false
         @report_rescued_exceptions = false
         @auto_instrument_active_job = false
         @excluded_exceptions = []
+        @use_tracing_headers = true
         @capture_user_context = true
         @current_user_method = :current_user
         @user_id_method = nil
       end
 
-      # Default exceptions that Rails apps typically don't want to track
+      # Default exceptions that Rails apps typically don't want to track.
+      #
+      # @return [Array<String>]
       def default_excluded_exceptions
         [
           'AbstractController::ActionNotFound',
@@ -54,6 +62,8 @@ module PostHog
         ]
       end
 
+      # @param exception [Exception] The exception to check.
+      # @return [Boolean] Whether the exception should be captured.
       def should_capture_exception?(exception)
         exception_name = exception.class.name
         !all_excluded_exceptions.include?(exception_name)

data/lib/posthog/rails/error_subscriber.rb

@@ -4,11 +4,19 @@ require 'posthog/rails/parameter_filter'
 
 module PostHog
   module Rails
-    # Rails 7.0+ error reporter integration
-    # This integrates with Rails.error.handle and Rails.error.record
+    # Rails 7.0+ error reporter integration.
+    # This integrates with Rails.error.handle and Rails.error.record.
+    #
+    # @api private
     class ErrorSubscriber
       include ParameterFilter
 
+      # @param error [Exception] Error reported by Rails.
+      # @param handled [Boolean]
+      # @param severity [Symbol, String]
+      # @param context [Hash]
+      # @param source [String, nil]
+      # @return [void]
       def report(error, handled:, severity:, context:, source: nil)
         return unless PostHog::Rails.config&.auto_capture_exceptions
         return unless PostHog::Rails.config&.should_capture_exception?(error)

data/lib/posthog/rails/parameter_filter.rb

@@ -9,6 +9,8 @@ module PostHog
     # It automatically detects the correct Rails parameter filtering API based on
     # the Rails version.
     #
+    # @api private
+    #
     # @example Usage in a class
     #   class MyClass
     #     include PostHog::Rails::ParameterFilter
@@ -24,10 +26,12 @@ module PostHog
       MAX_DEPTH = 10
 
       if ::Rails.version.to_f >= 6.0
+        # @return [Class] Rails parameter filter backend.
         def self.backend
           ActiveSupport::ParameterFilter
         end
       else
+        # @return [Class] Rails parameter filter backend.
         def self.backend
           ActionDispatch::Http::ParameterFilter
         end

data/lib/posthog/rails/railtie.rb

@@ -21,7 +21,11 @@ module PostHog
               get_all_flags
             ].freeze
 
-            # Initialize PostHog client with a block configuration
+            # Initialize the singleton PostHog client used by Rails delegators.
+            #
+            # @param options [Hash] Core {PostHog::Client} options.
+            # @yieldparam config [PostHog::Rails::InitConfig] Block-based core SDK configuration.
+            # @return [PostHog::Client]
             def init(options = {})
               # If block given, yield to configuration
               if block_given?
@@ -42,11 +46,14 @@ module PostHog
               end
             end
 
+            # @return [Boolean] Whether {PostHog.init} has created a client.
             def initialized?
               !@client.nil?
             end
 
-            # Fallback for any client methods not explicitly defined
+            # Fallback for any client methods not explicitly defined.
+            #
+            # @api private
             # rubocop:disable Lint/RedundantSafeNavigation
             def method_missing(method_name, ...)
               if client&.respond_to?(method_name)
@@ -57,6 +64,7 @@ module PostHog
               end
             end
 
+            # @api private
             def respond_to_missing?(method_name, include_private = false)
               client&.respond_to?(method_name) || super
             end
@@ -73,8 +81,15 @@ module PostHog
         end
       end
 
-      # Insert middleware for exception capturing
+      # Insert middleware for request context and exception capturing
       initializer 'posthog.insert_middlewares' do |app|
+        # Wrap the Rails exception middleware so request context is active for
+        # downstream handlers and exception capture.
+        insert_middleware_before(
+          app, ActionDispatch::ShowExceptions,
+          PostHog::Rails::RequestContext
+        )
+
         # Insert after DebugExceptions to catch rescued exceptions
         insert_middleware_after(
           app, ActionDispatch::DebugExceptions,
@@ -111,6 +126,8 @@ module PostHog
         at_exit { PostHog.client&.shutdown if PostHog.initialized? }
       end
 
+      # @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.)
@@ -118,6 +135,17 @@ module PostHog
         app.config.middleware.insert_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)
+      end
+
+      # @api private
+      # @return [void]
       def self.register_error_subscriber
         return unless PostHog::Rails.config&.auto_capture_exceptions
 
@@ -128,6 +156,8 @@ module PostHog
         PostHog::Logging.logger.warn("Backtrace: #{e.backtrace&.first(5)&.join("\n")}")
       end
 
+      # @api private
+      # @return [Boolean]
       def self.rails_version_above_7?
         ::Rails.version.to_f >= 7.0
       end
@@ -135,51 +165,74 @@ module PostHog
 
     # Configuration wrapper for the init block
     class InitConfig
+      # @param base_options [Hash] Initial core SDK options.
       def initialize(base_options = {})
         @base_options = base_options
       end
 
       # Core PostHog options
+      #
+      # @param value [String]
+      # @return [String]
       def api_key=(value)
         @base_options[:api_key] = value
       end
 
+      # @param value [String, nil]
+      # @return [String, nil]
       def personal_api_key=(value)
         @base_options[:personal_api_key] = value
       end
 
+      # @param value [String]
+      # @return [String]
       def host=(value)
         @base_options[:host] = value
       end
 
+      # @param value [Integer]
+      # @return [Integer]
       def max_queue_size=(value)
         @base_options[:max_queue_size] = value
       end
 
+      # @param value [Boolean]
+      # @return [Boolean]
       def test_mode=(value)
         @base_options[:test_mode] = value
       end
 
+      # @param value [Boolean]
+      # @return [Boolean]
       def sync_mode=(value)
         @base_options[:sync_mode] = value
       end
 
+      # @param value [Proc]
+      # @return [Proc]
       def on_error=(value)
         @base_options[:on_error] = value
       end
 
+      # @param value [Integer]
+      # @return [Integer]
       def feature_flags_polling_interval=(value)
         @base_options[:feature_flags_polling_interval] = value
       end
 
+      # @param value [Integer]
+      # @return [Integer]
       def feature_flag_request_timeout_seconds=(value)
         @base_options[:feature_flag_request_timeout_seconds] = value
       end
 
+      # @param value [Proc]
+      # @return [Proc]
       def before_send=(value)
         @base_options[:before_send] = value
       end
 
+      # @return [Hash] Core SDK options suitable for {PostHog::Client.new}.
       def to_client_options
         @base_options
       end

data/lib/posthog/rails/request_context.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'posthog/internal/context'
+require 'posthog/rails/tracing_headers'
+require 'posthog/rails/request_metadata'
+
+module PostHog
+  module Rails
+    # Rack middleware that creates a request-local PostHog context from tracing headers.
+    #
+    # @api private
+    class RequestContext
+      # @param app [#call] Rack application.
+      def initialize(app)
+        @app = app
+      end
+
+      # @param env [Hash] Rack environment.
+      # @return [Array] Rack response.
+      def call(env)
+        request = build_request(env)
+
+        Internal::Context.with_context(context_data(request), fresh: true) do
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def context_data(request)
+        data = { properties: request_properties(request) }
+        return data unless use_tracing_headers?
+
+        data.merge(
+          distinct_id: tracing_header(request, 'X-POSTHOG-DISTINCT-ID'),
+          session_id: tracing_header(request, 'X-POSTHOG-SESSION-ID')
+        )
+      end
+
+      def use_tracing_headers?
+        PostHog::Rails.config&.use_tracing_headers != false
+      end
+
+      def request_properties(request)
+        RequestMetadata.extract(request)
+      end
+
+      def tracing_header(request, header_name)
+        TracingHeaders.extract_header(request, header_name)
+      end
+
+      def build_request(env)
+        if defined?(ActionDispatch::Request)
+          ActionDispatch::Request.new(env)
+        elsif defined?(Rack::Request)
+          Rack::Request.new(env)
+        else
+          env
+        end
+      end
+    end
+  end
+end

data/lib/posthog/rails/request_metadata.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'posthog/rails/tracing_headers'
+
+module PostHog
+  module Rails
+    # Internal helpers for extracting request metadata owned by RequestContext.
+    #
+    # @api private
+    module RequestMetadata
+      module_function
+
+      # @param request [Object] Rack or Rails request object.
+      # @return [Hash] Event properties extracted from the request.
+      def extract(request)
+        properties = {}
+        add_property(properties, '$current_url', current_url(request))
+        request_method = request_value(request, :request_method) || request_value(request, :method)
+        add_property(properties, '$request_method', request_method)
+        add_property(properties, '$request_path', request_value(request, :path) || request_value(request, :path_info))
+        add_property(properties, '$user_agent', TracingHeaders.extract_header(request, 'User-Agent'))
+        add_property(properties, '$ip', client_ip(request))
+        properties
+      end
+
+      def current_url(request)
+        url = request_value(request, :url)
+        return if url.nil?
+
+        url.to_s.split('?', 2).first
+      end
+      private_class_method :current_url
+
+      def client_ip(request)
+        trusted_ip = request_value(request, :remote_ip) || request_value(request, :ip)
+        return trusted_ip if present?(trusted_ip)
+
+        forwarded_for = TracingHeaders.extract_header(request, 'X-Forwarded-For')
+        forwarded_ip = forwarded_for.split(',').first&.strip if forwarded_for
+        return forwarded_ip if present?(forwarded_ip)
+
+        env_value(request, 'REMOTE_ADDR')
+      end
+      private_class_method :client_ip
+
+      def present?(value)
+        !(value.nil? || (value.respond_to?(:empty?) && value.empty?))
+      end
+      private_class_method :present?
+
+      def add_property(properties, key, value)
+        return if value.nil?
+
+        serialized = value.to_s
+        return if serialized.empty?
+
+        properties[key] = serialized
+      end
+      private_class_method :add_property
+
+      def request_value(request, method_name)
+        return unless request.respond_to?(method_name)
+
+        request.public_send(method_name)
+      rescue StandardError
+        nil
+      end
+      private_class_method :request_value
+
+      def env_value(request, key)
+        request.respond_to?(:get_header) ? request.get_header(key) : request.env[key]
+      rescue StandardError
+        nil
+      end
+      private_class_method :env_value
+    end
+
+    private_constant :RequestMetadata
+  end
+end

data/lib/posthog/rails/rescued_exception_interceptor.rb

@@ -2,14 +2,19 @@
 
 module PostHog
   module Rails
-    # Middleware that intercepts exceptions that are rescued by 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
+    # so we can report it even if Rails rescues it.
+    #
+    # @api private
     class RescuedExceptionInterceptor
+      # @param app [#call] Rack application.
       def initialize(app)
         @app = app
       end
 
+      # @param env [Hash] Rack environment.
+      # @return [Array] Rack response.
       def call(env)
         @app.call(env)
       rescue StandardError => e

data/lib/posthog/rails/tracing_headers.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PostHog
+  module Rails
+    # Helpers for extracting and sanitizing PostHog tracing headers from Rack/Rails requests.
+    #
+    # @api private
+    module TracingHeaders
+      MAX_HEADER_VALUE_LENGTH = 1000
+      CONTROL_CHARACTERS = /[[:cntrl:]]/
+
+      module_function
+
+      # @param value [Object]
+      # @return [String, nil]
+      def sanitize_header_value(value)
+        return nil unless value.is_a?(String)
+
+        sanitized = value.strip.gsub(CONTROL_CHARACTERS, '').strip
+        return nil if sanitized.empty?
+
+        sanitized[0, MAX_HEADER_VALUE_LENGTH]
+      end
+
+      # @param request_or_env [Object, Hash] Rack request, Rails request, or Rack env hash.
+      # @param header_name [String]
+      # @return [String, nil]
+      def extract_header(request_or_env, header_name)
+        candidates = header_candidates(header_name)
+
+        candidates.each do |candidate|
+          value = header_value(request_or_env, candidate)
+          sanitized = sanitize_header_value(value)
+          return sanitized if sanitized
+        end
+
+        env = request_env(request_or_env)
+        return nil unless env.respond_to?(:each)
+
+        target_names = candidates.map { |candidate| normalize_header_name(candidate) }
+        env.each do |key, value|
+          next unless target_names.include?(normalize_header_name(key))
+
+          sanitized = sanitize_header_value(value)
+          return sanitized if sanitized
+        end
+
+        nil
+      end
+
+      def header_candidates(header_name)
+        canonical = header_name.to_s
+        rack = "HTTP_#{canonical.upcase.tr('-', '_')}"
+        [canonical, canonical.downcase, rack]
+      end
+      private_class_method :header_candidates
+
+      def header_value(request_or_env, header_name)
+        if request_or_env.respond_to?(:headers)
+          value = request_or_env.headers[header_name]
+          return value unless value.nil?
+        end
+
+        env = request_env(request_or_env)
+        return nil unless env.respond_to?(:[])
+
+        env[header_name]
+      end
+      private_class_method :header_value
+
+      def request_env(request_or_env)
+        request_or_env.respond_to?(:env) ? request_or_env.env : request_or_env
+      end
+      private_class_method :request_env
+
+      def normalize_header_name(header_name)
+        header_name.to_s.upcase.tr('-', '_')
+      end
+      private_class_method :normalize_header_name
+    end
+
+    private_constant :TracingHeaders
+  end
+end

data/lib/posthog/rails.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'posthog/rails/configuration'
+require 'posthog/rails/tracing_headers'
+require 'posthog/rails/request_metadata'
+require 'posthog/rails/request_context'
 require 'posthog/rails/capture_exceptions'
 require 'posthog/rails/rescued_exception_interceptor'
 require 'posthog/rails/active_job'
@@ -15,29 +18,41 @@ module PostHog
     IN_WEB_REQUEST_KEY = :posthog_in_web_request
 
     class << self
+      # @return [PostHog::Rails::Configuration] Rails integration configuration.
       def config
         @config ||= Configuration.new
       end
 
+      # @param config [PostHog::Rails::Configuration] Rails integration configuration.
       attr_writer :config
 
+      # Configure Rails integration options.
+      #
+      # @yieldparam config [PostHog::Rails::Configuration]
+      # @return [void]
       def configure
         yield config if block_given?
       end
 
       # Mark that we're in a web request context
       # CaptureExceptions middleware will handle exception capture
+      # @api private
+      # @return [void]
       def enter_web_request
         Thread.current[IN_WEB_REQUEST_KEY] = true
       end
 
       # Clear web request context (called at end of request)
+      # @api private
+      # @return [void]
       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
+      # @api private
+      # @return [Boolean]
       def in_web_request?
         Thread.current[IN_WEB_REQUEST_KEY] == true
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: posthog-rails
 version: !ruby/object:Gem::Version
-  version: 3.8.1
+  version: 3.9.1
 platform: ruby
 authors:
 - PostHog
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.9'
 description: Automatic exception tracking and instrumentation for Ruby on Rails applications
   using PostHog
 email: engineering@posthog.com
@@ -54,7 +54,10 @@ files:
 - lib/posthog/rails/error_subscriber.rb
 - lib/posthog/rails/parameter_filter.rb
 - lib/posthog/rails/railtie.rb
+- lib/posthog/rails/request_context.rb
+- lib/posthog/rails/request_metadata.rb
 - lib/posthog/rails/rescued_exception_interceptor.rb
+- lib/posthog/rails/tracing_headers.rb
 homepage: https://github.com/PostHog/posthog-ruby
 licenses:
 - MIT