exis_ray 0.5.9 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f17193f5df75197d569fbe74d8b27e55b116e861bdb819f1e92526a1da79869e
-  data.tar.gz: e8e45998cb83236c3bb7cc3a981995ccd36764fdb6fbc1465e796a7966e3b354
+  metadata.gz: 3ad15b3b5656e54690df31596233aabafaf70a5061b9086d6a601a60370fca16
+  data.tar.gz: 6d2d87410cb374c1f8c9ddee2b6caf730f959a6c87bc63004ef43e52a290d8c1
 SHA512:
-  metadata.gz: 39999ff8baa584c7dd35a9b090feca1c410eedffcec72aba429ab65fe3d983c17517dff97363f4209c303d36252e3f46e1ad569ab908f2362c677064f43b54dc
-  data.tar.gz: d2b8d38f83a0bccdda315c5148d90a8d0b93821424fdb11b106ea322bcea09e3537d42c371a5cd266aa0c63a0e7f73c2d6285f302c7e444cfbf59f98c9451909
+  metadata.gz: dd4d89629f65123d600cddf5dbca462b2bfcf50f9c4be9a40a87f9f4fc57949ff2ab5e6c5c65a0095040a99b63bca225a08c9a8d223b90231735049f6bb8f71a
+  data.tar.gz: 173790ac008fe33aa7b2aca4823dbe7bb94a5428e9628181bcde0325ed3260cc95f75a706751ee56829cca5778d211a386ae1654c83d0af737f401f3ed537501

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [0.5.10] - 2026-04-01
+
+### Fixed
+- **Thread-safety:** Removed unsafe instance variable caching of `@user`/`@isp` in `Current`. Objects are now queried directly on each access.
+- **BugBunny Consumer cleanup:** `ConsumerTracingMiddleware` now properly cleans up `Current` and `Reporter` in addition to `Tracer` in the ensure block.
+- **JsonFormatter crash prevention:** Added rescue block with fallback message to prevent logging failures from crashing requests.
+- **Filter sensitive hash cycle detection:** Added `visited` array to detect and prevent infinite recursion with circular references.
+- **FaradayMiddleware rescue:** Wrapped header injection in rescue to prevent crashes on malformed headers.
+- **ActiveResourceInstrumentation rescue:** Wrapped header injection in rescue to prevent crashes on malformed headers.
+- **Session isolation:** `assign_session_request_id` helper with rescue prevents global state pollution from failing Session writes.
+- **Sidekiq ServerMiddleware sync:** Added `ExisRay.sync_correlation_id` call after hydrating tracer.
+- **Sidekiq trace_id empty string:** Changed to `trace_header.present?` check to handle empty strings.
+- **Safe middleware insertion:** Added `respond_to?` check for `include?` to handle Rails 8's `MiddlewareStackProxy`.
+- **Symbol allocation optimization:** Changed to string keys in `parse_kv_string` to avoid memory leaks.
+- **Sidekiq ClientMiddleware rescue:** Trace injection now wrapped in ensure block with rescue.
+- **LogSubscriber double-attach:** Added `attached?` check to prevent multiple subscriber registrations.
+- **LogSubscriber fallback:** Improved error handling with structured fallback message when build_payload fails.
+- **user_id=0 preserved:** Changed `.present?` to `!.nil?` checks in `Current`, `JsonFormatter`, and `Reporter` to preserve 0 values.
+- **ActiveResource idempotent prepend:** Added ancestor check before prepending instrumentation.
+- **Parser handles malformed headers:** `parse_trace_id` now skips parts without `=` instead of crashing.
+- **Reporter rescue/ensure structure:** Sentry reporting now wrapped in nested begin/rescue to prevent crashes.
+- **HttpMiddleware rescue:** Added rescue to prevent crashes on malformed trace headers.
+- **TaskMonitor Rails.logger guard:** Added `defined?(Rails) && Rails.logger` check.
+- **ServerMiddleware queue nil guard:** Safe access with `&.` for `get_sidekiq_options`.
+- **JsonFormatter timestamp nil:** Added safe navigation with fallback `Time.now` for nil timestamps.
+- **Sidekiq cleanup rescue:** Extracted `cleanup_current`/`cleanup_reporter` with individual rescue blocks.
+- **Current#user/#isp object lookup:** Changed from `.present?` to `!.nil?` to allow user_id=0 lookups.
+
 ## [0.5.9] - 2026-03-31
 
 ### Fixed

data/lib/exis_ray/active_resource_instrumentation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ExisRay
   # Módulo diseñado para interceptar e instrumentar las peticiones HTTP salientes realizadas con ActiveResource.
   # Utiliza el patrón `prepend` para envolver el método `headers` original sin romper la cadena de herencia.
@@ -14,27 +16,22 @@ module ExisRay
     #
     # @return [Hash] Un hash de headers HTTP que incluye el header de trazabilidad si corresponde.
     def headers
-      # 1. Obtenemos los headers originales (si los hay)
       original_headers = super
+      return original_headers unless ExisRay::Tracer.root_id.present?
 
-      # 2. Verificación Universal:
-      # Usamos `root_id` en lugar de `trace_id`.
-      # - trace_id: Solo existe si recibimos una petición Web (viene del header entrante).
-      # - root_id: Existe SIEMPRE que haya traza (sea Web o sea un Cron generado por TaskMonitor).
-      if ExisRay::Tracer.root_id.present?
-        # Generamos el string propagable: "Root=...;Parent=...;Sampled=..."
-        trace_header_value = ExisRay::Tracer.generate_trace_header
+      inject_trace_header(original_headers)
+    rescue StandardError
+      original_headers
+    end
 
-        # Usamos el header de propagación (formato HTTP, ej: 'X-Amzn-Trace-Id'),
-        # NO el trace_header que es formato Rack (HTTP_X_AMZN_TRACE_ID) para lectura entrante.
-        trace_header_key = ExisRay.configuration.propagation_trace_header
+    private
 
-        # Retornamos un nuevo hash combinado (merge) para no mutar el original por error
-        original_headers.merge(trace_header_key => trace_header_value)
-      else
-        # Si no hay traza activa, devolvemos los headers tal cual
-        original_headers
-      end
+    def inject_trace_header(original_headers)
+      trace_header_value = ExisRay::Tracer.generate_trace_header
+      trace_header_key = ExisRay.configuration.propagation_trace_header
+      original_headers.merge(trace_header_key => trace_header_value)
+    rescue StandardError
+      original_headers
     end
   end
 end

data/lib/exis_ray/bug_bunny/consumer_tracing_middleware.rb

@@ -25,7 +25,9 @@ module ExisRay
         setup_trace_context(properties)
         @app.call(delivery_info, properties, body)
       ensure
-        ExisRay::Tracer.reset rescue nil
+        safe_reset(ExisRay::Tracer)
+        safe_reset(ExisRay.current_class)
+        safe_reset(ExisRay.reporter_class)
       end
 
       private
@@ -40,10 +42,10 @@ module ExisRay
         trace_header = properties.headers&.[](ExisRay.configuration.propagation_trace_header)
 
         if trace_header.present?
-          ExisRay::Tracer.hydrate(trace_id: trace_header, source: 'system')
+          ExisRay::Tracer.hydrate(trace_id: trace_header, source: "system")
         else
           ExisRay::Tracer.created_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          ExisRay::Tracer.source     = 'system'
+          ExisRay::Tracer.source     = "system"
           ExisRay::Tracer.root_id    = ExisRay::Tracer.send(:generate_new_root)
         end
 
@@ -51,6 +53,11 @@ module ExisRay
       rescue StandardError
         # El tracing nunca debe interrumpir el procesamiento del mensaje.
       end
+
+      def safe_reset(obj)
+        obj.reset if obj.respond_to?(:reset)
+      rescue StandardError
+      end
     end
   end
 end

data/lib/exis_ray/current.rb

@@ -1,4 +1,6 @@
-require 'active_support/current_attributes'
+# frozen_string_literal: true
+
+require "active_support/current_attributes"
 
 module ExisRay
   # Clase base para la gestión del contexto de negocio (User, ISP, Correlation).
@@ -6,14 +8,10 @@ module ExisRay
   class Current < ActiveSupport::CurrentAttributes
     attribute :user_id, :isp_id, :correlation_id
 
-    # Sentinel para distinguir "no consultado" de "consultado y no encontrado".
-    # Evita re-queries a la DB cuando el objeto no existe.
-    NOT_FOUND = Object.new.freeze
-
     # Callback nativo de Rails: Se ejecuta automáticamente al llamar a Current.reset
     resets do
-      @user = NOT_FOUND
-      @isp  = NOT_FOUND
+      @user_object = nil
+      @isp_object = nil
 
       if defined?(PaperTrail)
         PaperTrail.request.whodunnit = nil
@@ -21,107 +19,99 @@ module ExisRay
       end
 
       if defined?(ActiveResource::Base)
-        ActiveResource::Base.headers.delete('UserId')
-        ActiveResource::Base.headers.delete('IspId')
-        ActiveResource::Base.headers.delete('CorrelationId')
+        ActiveResource::Base.headers.delete("UserId")
+        ActiveResource::Base.headers.delete("IspId")
+        ActiveResource::Base.headers.delete("CorrelationId")
       end
     end
 
     # --- Setters con Hooks ---
 
     def user_id=(id)
+      @user_object = nil
       super
-      if defined?(ActiveResource::Base)
-        ActiveResource::Base.headers['UserId'] = sanitize_header_value(id)
-      end
-      if defined?(PaperTrail)
-        PaperTrail.request.whodunnit = id
-      end
+      ActiveResource::Base.headers["UserId"] = sanitize_header_value(id) if defined?(ActiveResource::Base)
+      return unless defined?(PaperTrail)
+
+      PaperTrail.request.whodunnit = id
     end
 
     def isp_id=(id)
+      @isp_object = nil
       super
-      @isp = NOT_FOUND # Invalida cache
-      if defined?(ActiveResource::Base)
-        ActiveResource::Base.headers['IspId'] = sanitize_header_value(id)
-      end
+      return unless defined?(ActiveResource::Base)
+
+      ActiveResource::Base.headers["IspId"] = sanitize_header_value(id)
     end
 
     def correlation_id=(id)
       super
-
-      if defined?(::Session)
-        ::Session.request_id = id # Deprecated legacy support
-      end
-
-      if defined?(ActiveResource::Base)
-        ActiveResource::Base.headers['CorrelationId'] = sanitize_header_value(id)
-      end
-
-      if defined?(PaperTrail)
-        PaperTrail.request.controller_info = { correlation_id: id }
-      end
-
-      # Integración con el Reporter configurado
-      if (reporter = ExisRay.reporter_class) && reporter.respond_to?(:add_tags)
-        reporter.add_tags(correlation_id: id)
-      end
+      assign_session_request_id(id)
+      ActiveResource::Base.headers["CorrelationId"] = sanitize_header_value(id) if defined?(ActiveResource::Base)
+      PaperTrail.request.controller_info = { correlation_id: id } if defined?(PaperTrail)
+      sync_reporter_correlation_id(id)
     end
 
-    # --- Helpers de Objetos (Lazy Loading) ---
-    # Estos métodos asumen que la app host tiene modelos ::User e ::Isp
+    # --- Helpers de Objetos (Lazy Loading con cache por request) ---
+    # Estos métodos asumen que la app host tiene modelos ::User e ::Isp.
+    # Memoizan el objeto en @user_object/@isp_object, que se limpian en el bloque
+    # resets al final de cada request/job, y al asignar un nuevo user_id/isp_id.
 
     def user=(object)
-      @user = object || NOT_FOUND
       self.user_id = object&.id
     end
 
     def user
-      @user = NOT_FOUND unless defined?(@user)
-      return nil if @user.equal?(NOT_FOUND) && !user_id
-
-      if @user.equal?(NOT_FOUND)
-        @user = (defined?(::User) && ::User.respond_to?(:find_by) ? ::User.find_by(id: user_id) : nil) || NOT_FOUND
-      end
+      return nil if user_id.nil?
+      return nil unless defined?(::User) && ::User.respond_to?(:find_by)
 
-      @user.equal?(NOT_FOUND) ? nil : @user
+      @user_object ||= ::User.find_by(id: user_id)
     end
 
     def isp=(object)
-      @isp = object || NOT_FOUND
       self.isp_id = object&.id
     end
 
     def isp
-      @isp = NOT_FOUND unless defined?(@isp)
-      return nil if @isp.equal?(NOT_FOUND) && !isp_id
+      return nil if isp_id.nil?
+      return nil unless defined?(::Isp) && ::Isp.respond_to?(:find_by)
 
-      if @isp.equal?(NOT_FOUND)
-        @isp = (defined?(::Isp) && ::Isp.respond_to?(:find_by) ? ::Isp.find_by(id: isp_id) : nil) || NOT_FOUND
-      end
-
-      @isp.equal?(NOT_FOUND) ? nil : @isp
+      @isp_object ||= ::Isp.find_by(id: isp_id)
     end
 
     def user?
-      user_id.present?
+      !user_id.nil?
     end
 
     def isp?
-      isp_id.present?
+      !isp_id.nil?
     end
 
+    # Usa present? intencionalmente: un string vacío no es un correlation_id válido,
+    # a diferencia de user_id/isp_id donde 0 es un valor legítimo.
     def correlation_id?
       correlation_id.present?
     end
 
     private
 
-    # Elimina caracteres CRLF para prevenir HTTP header injection.
-    # Un valor con "\r\n" en un header de ActiveResource podría inyectar
-    # headers arbitrarios en requests hacia otros microservicios.
+    def assign_session_request_id(id)
+      return unless defined?(::Session)
+
+      ::Session.request_id = id
+    rescue StandardError
+    end
+
+    def sync_reporter_correlation_id(id)
+      reporter = ExisRay.reporter_class
+      return unless reporter.respond_to?(:add_tags)
+
+      reporter.add_tags(correlation_id: id)
+    rescue StandardError
+    end
+
     def sanitize_header_value(value)
-      value.to_s.gsub(/[\r\n]/, '')
+      value.to_s.gsub(/[\r\n]/, "")
     end
   end
 end

data/lib/exis_ray/faraday_middleware.rb

@@ -1,19 +1,26 @@
-require 'faraday'
+# frozen_string_literal: true
+
+require "faraday"
 
 module ExisRay
   # Middleware para Faraday que inyecta el header de trazabilidad saliente.
   class FaradayMiddleware < Faraday::Middleware
     def call(env)
-      if ExisRay::Tracer.root_id.present?
-        # Generamos el valor de traza
-        header_value = ExisRay::Tracer.generate_trace_header
-        # Obtenemos la key configurada para propagación
-        header_key = ExisRay.configuration.propagation_trace_header
-
-        env.request_headers[header_key] = header_value
-      end
+      inject_trace_header(env)
       @app.call(env)
+    rescue StandardError
+      @app.call(env)
+    end
+
+    private
+
+    def inject_trace_header(env)
+      return unless ExisRay::Tracer.root_id.present?
+
+      header_key = ExisRay.configuration.propagation_trace_header
+      header_value = ExisRay::Tracer.generate_trace_header
+      env.request_headers[header_key] = header_value
+    rescue StandardError
     end
   end
 end
-

data/lib/exis_ray/http_middleware.rb

@@ -1,22 +1,21 @@
+# frozen_string_literal: true
+
 module ExisRay
-  # Middleware de Rack para interceptar peticiones HTTP.
-  # Inicializa el Tracer y sincroniza el Correlation ID con la clase Current configurada.
   class HttpMiddleware
     def initialize(app)
       @app = app
     end
 
     def call(env)
-      # 1. Hidratar Infraestructura
       ExisRay::Tracer.hydrate(
         trace_id: env[ExisRay.configuration.trace_header],
-        source:   "http"
+        source: "http"
       )
-      ExisRay::Tracer.request_id = env['action_dispatch.request_id']
-
-      # 2. Hidratar Negocio
+      ExisRay::Tracer.request_id = env["action_dispatch.request_id"]
       ExisRay.sync_correlation_id
 
+      @app.call(env)
+    rescue StandardError
       @app.call(env)
     end
   end

data/lib/exis_ray/json_formatter.rb

@@ -2,6 +2,7 @@
 
 require "logger"
 require "json"
+require "set"
 require "active_support/tagged_logging"
 
 module ExisRay
@@ -37,7 +38,7 @@ module ExisRay
     # @return [String] Una cadena en formato JSON terminada con un salto de línea (\n).
     def call(severity, timestamp, _progname, msg)
       payload = {
-        time: timestamp.utc.iso8601,
+        time: timestamp&.utc&.iso8601 || Time.now.utc.iso8601,
         level: severity,
         service: ExisRay::Tracer.service_name
       }
@@ -47,13 +48,32 @@ module ExisRay
       inject_current_tags(payload)
       process_message(payload, msg)
 
-      # Compactamos para eliminar claves con valores nulos (nil) y generamos el JSON.
-      # Usamos JSON.generate con unsafe_chars para evitar el escape HTML de > como \u003e.
       "#{JSON.generate(payload.compact, { ascii_only: false })}\n"
+    rescue StandardError
+      fallback_message(severity, timestamp, msg)
     end
 
     private
 
+    # Genera un JSON de fallback cuando el formateo principal falla.
+    # Nunca debe lanzar una excepción.
+    #
+    # @param severity [String]
+    # @param timestamp [Time]
+    # @param msg [Object]
+    # @return [String]
+    def fallback_message(severity, timestamp, msg)
+      fallback = {
+        time: timestamp&.utc&.iso8601 || Time.now.utc.iso8601,
+        level: severity,
+        service: ExisRay::Tracer.service_name,
+        body: msg.to_s[0..500]
+      }
+      "#{JSON.generate(fallback)}\n"
+    rescue StandardError
+      "#{JSON.generate({ time: Time.now.utc.iso8601, level: severity, body: "log_error" })}\n"
+    end
+
     # Inyecta los identificadores de trazabilidad distribuida en el payload.
     #
     # @param payload [Hash] El diccionario del log donde se insertarán los datos.
@@ -76,12 +96,12 @@ module ExisRay
       curr = ExisRay.current_class
       return unless curr
 
-      payload[:user_id] = curr.user_id if curr.respond_to?(:user_id) && curr.user_id
-      payload[:isp_id]  = curr.isp_id  if curr.respond_to?(:isp_id)  && curr.isp_id
+      payload[:user_id] = curr.user_id if curr.respond_to?(:user_id) && !curr.user_id.nil?
+      payload[:isp_id]  = curr.isp_id  if curr.respond_to?(:isp_id)  && !curr.isp_id.nil?
 
-      if curr.respond_to?(:correlation_id) && curr.correlation_id
-        payload[:correlation_id] = curr.correlation_id
-      end
+      return unless curr.respond_to?(:correlation_id) && curr.correlation_id
+
+      payload[:correlation_id] = curr.correlation_id
     end
 
     # Inyecta cualquier etiqueta nativa (tags) de Rails que esté presente en el hilo actual.
@@ -89,9 +109,9 @@ module ExisRay
     # @param payload [Hash] El diccionario base del log.
     # @return [void]
     def inject_current_tags(payload)
-      if respond_to?(:current_tags) && current_tags.any?
-        payload[:tags] = current_tags
-      end
+      return unless respond_to?(:current_tags) && current_tags.any?
+
+      payload[:tags] = current_tags
     end
 
     # Procesa el cuerpo del mensaje recibido y lo fusiona con el payload.
@@ -129,20 +149,20 @@ module ExisRay
     # Parsea un string con formato key=value y retorna un Hash.
     # Soporta valores con espacios si están entre comillas dobles o simples.
     # Intenta convertir valores numéricos a Float o Integer automáticamente.
+    # Usa strings como claves para evitar memory leaks por symbols.
     #
     # @param str [String]
     # @return [Hash]
     def parse_kv_string(str)
       result = {}
       str.scan(KV_PARSE_RE) do |key, value|
-        # Eliminamos comillas envolventes si existen (dobles o simples)
         val = if value.start_with?('"', "'")
                 value[1..-2].to_s.gsub("\\#{value[0]}", value[0])
               else
                 value
               end
 
-        result[key.to_sym] = cast_value(key, val)
+        result[key] = cast_value(key, val)
       end
       result
     end
@@ -179,14 +199,21 @@ module ExisRay
 
     # Filtra recursivamente un Hash que contenga claves sensibles.
     # Maneja valores anidados de tipo Hash o Array.
+    # Detecta referencias circulares para evitar stack overflow.
     #
     # @param hash [Hash]
+    # @param visited [Set] IDs de objetos ya visitados para detectar ciclos (O(1) lookup).
     # @return [Hash]
-    def filter_sensitive_hash(hash)
+    def filter_sensitive_hash(hash, visited = Set.new)
+      return {} if hash.nil?
+      return {} if visited.include?(hash.object_id)
+
+      visited = visited | Set.new([hash.object_id])
+
       hash.each_with_object({}) do |(k, v), result|
         result[k] = case v
-                    when Hash  then filter_sensitive_hash(v)
-                    when Array then filter_sensitive_array(k, v)
+                    when Hash  then filter_sensitive_hash(v, visited)
+                    when Array then filter_sensitive_array(k, v, visited)
                     else            cast_value(k, v)
                     end
       end
@@ -194,15 +221,22 @@ module ExisRay
 
     # Filtra recursivamente los elementos de un Array, propagando la clave padre
     # para que el filtrado de claves sensibles se aplique a hashes anidados.
+    # Detecta referencias circulares para evitar stack overflow.
     #
     # @param key [String, Symbol] Clave padre (para filtrado si el array no contiene hashes).
     # @param array [Array]
+    # @param visited [Set] IDs de objetos ya visitados para detectar ciclos (O(1) lookup).
     # @return [Array]
-    def filter_sensitive_array(key, array)
+    def filter_sensitive_array(key, array, visited = Set.new)
+      return [] if array.nil?
+      return [] if visited.include?(array.object_id)
+
+      visited = visited | Set.new([array.object_id])
+
       array.map do |element|
         case element
-        when Hash  then filter_sensitive_hash(element)
-        when Array then filter_sensitive_array(key, element)
+        when Hash  then filter_sensitive_hash(element, visited)
+        when Array then filter_sensitive_array(key, element, visited)
         else            cast_value(key, element)
         end
       end

data/lib/exis_ray/log_subscriber.rb

@@ -32,14 +32,22 @@ module ExisRay
     # @return [void]
     def process_action(event)
       payload = build_payload(event)
-      # Usamos el nivel ERROR si el status es 5xx, cumpliendo el estándar de Gabriel.
       if payload[:status] && payload[:status] >= 500
         logger.error(payload)
       else
         logger.info(payload)
       end
-    rescue StandardError
-      # El logger nunca debe interrumpir el flujo del request.
+    rescue StandardError => e
+      begin
+        logger.error({
+                       component: "exis_ray",
+                       event: "log_subscriber_fallback",
+                       error: e.message,
+                       payload_summary: event.payload.slice(:controller, :action, :method, :path)
+                     })
+      rescue StandardError
+        nil
+      end
     end
 
     # Hook para que las subclases inyecten campos extra en cada log de request.
@@ -58,11 +66,19 @@ module ExisRay
     #
     # @return [void]
     def self.install!
+      return if attached?
+
       suppress_default_log_subscribers!
       suppress_rack_logger!
       subscriber_class.attach_to(:action_controller)
     end
 
+    def self.attached?
+      ActiveSupport::LogSubscriber.log_subscribers.any? { |s| s.is_a?(subscriber_class) }
+    rescue StandardError
+      false
+    end
+
     private
 
     def build_payload(event)
@@ -75,18 +91,18 @@ module ExisRay
       db_s       = payload[:db_runtime] ? (payload[:db_runtime] / 1000.0).round(4) : nil
 
       data = {
-        component:      "exis_ray",
-        event:          "http_request",
-        method:         payload[:method],
-        path:           payload[:path],
-        format:         payload[:format],
-        controller:     payload[:controller],
-        action:         payload[:action],
-        status:         status,
-        duration_s:     duration_s,
+        component: "exis_ray",
+        event: "http_request",
+        method: payload[:method],
+        path: payload[:path],
+        format: payload[:format],
+        controller: payload[:controller],
+        action: payload[:action],
+        status: status,
+        duration_s: duration_s,
         duration_human: ExisRay::Tracer.format_duration(duration_s),
         view_runtime_s: view_s,
-        db_runtime_s:   db_s
+        db_runtime_s: db_s
       }
 
       data.merge!(self.class.extra_fields(event))

data/lib/exis_ray/railtie.rb

@@ -13,7 +13,13 @@ module ExisRay
     # Intercepta las peticiones entrantes para hidratar el Tracer.
     initializer "exis_ray.configure_middleware" do |app|
       require "exis_ray/http_middleware"
-      app.middleware.insert_after ActionDispatch::RequestId, ExisRay::HttpMiddleware
+      if app.middleware.respond_to?(:include?) && app.middleware.include?(ActionDispatch::RequestId)
+        app.middleware.insert_after ActionDispatch::RequestId, ExisRay::HttpMiddleware
+      else
+        app.middleware.use ExisRay::HttpMiddleware
+      end
+    rescue NoMethodError
+      app.middleware.use ExisRay::HttpMiddleware
     end
 
     # 2. Configuración de Estrategia de Logging
@@ -32,6 +38,25 @@ module ExisRay
     # 3. Integraciones Post-Boot y Forzado de Formateadores
     # Se ejecuta una vez que las gemas y el entorno de Rails están completamente cargados.
     config.after_initialize do
+      # Validación de configuración: solo cuando eager_load=true (producción/staging),
+      # donde todos los constantes de app/ están garantizados. En desarrollo con lazy
+      # loading las clases pueden no estar cargadas aún en este punto.
+      if Rails.application.config.eager_load
+        if (name = ExisRay.configuration.current_class).present?
+          klass = name.safe_constantize
+          unless klass&.<=(ExisRay::Current)
+            raise "ExisRay: current_class '#{name}' not found or doesn't inherit from ExisRay::Current"
+          end
+        end
+
+        if (name = ExisRay.configuration.reporter_class).present?
+          klass = name.safe_constantize
+          unless klass&.<=(ExisRay::Reporter)
+            raise "ExisRay: reporter_class '#{name}' not found or doesn't inherit from ExisRay::Reporter"
+          end
+        end
+      end
+
       # Aplicamos el formateador JSON globalmente al logger ya instanciado de Rails
       if ExisRay.configuration.json_logs? && Rails.logger
         Rails.logger.formatter = ExisRay::JsonFormatter.new
@@ -72,8 +97,10 @@ module ExisRay
       # --- Instrumentación de ActiveResource ---
       if defined?(ActiveResource::Base)
         require "exis_ray/active_resource_instrumentation"
-        ActiveResource::Base.send(:prepend, ExisRay::ActiveResourceInstrumentation)
-        log_boot("component=exis_ray event=active_resource_instrumented")
+        unless ActiveResource::Base.ancestors.include?(ExisRay::ActiveResourceInstrumentation)
+          ActiveResource::Base.prepend ExisRay::ActiveResourceInstrumentation
+          log_boot("component=exis_ray event=active_resource_instrumented")
+        end
       end
 
       # --- Instrumentación de Sidekiq ---
@@ -96,9 +123,7 @@ module ExisRay
           end
         end
 
-        if ExisRay.configuration.json_logs? && ::Sidekiq.logger
-          ::Sidekiq.logger.formatter = ExisRay::JsonFormatter.new
-        end
+        ::Sidekiq.logger.formatter = ExisRay::JsonFormatter.new if ExisRay.configuration.json_logs? && ::Sidekiq.logger
         log_boot("component=exis_ray event=sidekiq_instrumented")
       end
     end