event_timeline 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f9b39a082143ef828a48c1ba89377103062e5fd2d356658d257964727402c22
-  data.tar.gz: f332374e2650e04ae7cfe4dee1ae27d98b11d268486284afbd02ddba8def7576
+  metadata.gz: 9dec56c4ce296fc94cb66f0065008565e072323dcd5b0dc4dd6f1bb719bf55f5
+  data.tar.gz: df8f292526aab228bef0084b8e455c6d002dd3b0a971ac328ca112e077f1e04b
 SHA512:
-  metadata.gz: c7ff33b22475ea362d891023c7fc942e9ee85878d13fba5cf113426e3aea0ba1b48e10ad9a6f0ea101b5dd740900beaacd65b021a2a0903fc70f8d51ba2bc9b1
-  data.tar.gz: 44ccc4f17fdb6e65f247a5209cec9cea0e6f458593ad113522b1da7056f9ca846db487a1f0d6cbbbcd5faca12c6be9be5ca1c917d17ae52674f23a58d43b25e3
+  metadata.gz: 2ed301440c1362f9a14ab63e545618b8ed29710e9f7bd4bc5d02de7e1cfa426cdfc412d527b49926ed2fb153ec9fb8ef18f0d1bdd1197c218c7b674815724d70
+  data.tar.gz: 4cc08a61b6de7c4d3b1312b136b387eb43935ed38aeb23fbf4fec482f705afe04fc73c09e1d235591c11727487a09cbe766a101e83b41729a3406e8621f2d2bb

data/README.md

@@ -77,6 +77,8 @@ EventTimeline::CallTracker.install!     # start tracking
 EventTimeline::CallTracker.installed?   # check status
 ```
 
+Methods are attached when their class loads, so configure `watch` before boot. To pick up paths added later, run `uninstall!` then `install!`.
+
 ## Custom correlation IDs
 
 For background jobs or anything outside a request:
@@ -88,7 +90,8 @@ EventTimeline::CurrentCorrelation.id = "import-job-#{job.id}"
 ## Limitations
 
 - Only tracks Ruby method calls (not SQL queries or HTTP calls)
-- TracePoint has some overhead - probably don't enable in high-traffic production without sampling
+- Code outside watched files costs nothing
+- Methods defined at runtime, after their class loaded, are not traced
 - Large values get truncated
 
 ## License

data/lib/event_timeline/call_tracker.rb

@@ -4,54 +4,55 @@ module EventTimeline
   class CallTracker
     THREAD_KEY_METHOD_STACK = :event_timeline_method_stack
     THREAD_KEY_EVENT_BUFFER = :event_timeline_event_buffer
+    THREAD_KEY_EVENT_SEQUENCE = :event_timeline_event_sequence
 
     class << self
-      attr_reader :call_trace, :return_trace
-
       def install!
         return if installed?
 
-        @call_trace = TracePoint.new(:call) { |tp| handle_call(tp) }
-        @return_trace = TracePoint.new(:return) { |tp| handle_return(tp) }
-
-        @call_trace.enable
-        @return_trace.enable
+        @traces = {}
+        ObjectSpace.each_object(Module) do |mod|
+          attach(mod) unless deprecated_constant?(mod) || mod.singleton_class?
+        rescue StandardError => e
+          Rails.logger.warn "EventTimeline could not attach to #{mod.name}: #{e.message}"
+        end
+        register_autoload_hooks
       end
 
       def uninstall!
-        @call_trace&.disable
-        @return_trace&.disable
-        @call_trace = nil
-        @return_trace = nil
+        @traces&.each_value { |traces| traces.each(&:disable) }
+        @traces = nil
       end
 
       def installed?
-        @call_trace&.enabled? || @return_trace&.enabled?
+        !@traces.nil?
       end
 
-      def flush_events(correlation_id)
+      def flush_events(_correlation_id)
         buffer = thread_event_buffer
         return if buffer.empty?
 
-        buffer_size = buffer.size
         Session.insert_all(buffer)
-
-        RotationService.enforce_correlation_limit(correlation_id, buffer_size)
         RotationService.cleanup_if_needed
       rescue StandardError => e
         Rails.logger.error "EventTimeline flush failed: #{e.message}" if defined?(Rails.logger)
+      ensure
+        Thread.current[THREAD_KEY_EVENT_BUFFER] = []
+        Thread.current[THREAD_KEY_EVENT_SEQUENCE] = nil
       end
 
       def cleanup_thread_state(correlation_id)
         thread_method_stack.delete(correlation_id)
         Thread.current[THREAD_KEY_EVENT_BUFFER] = []
+        Thread.current[THREAD_KEY_EVENT_SEQUENCE] = nil
       end
 
       def record_exception(exception, correlation_id)
         backtrace = clean_backtrace(exception.backtrace || [])
         source_location = extract_source_location(backtrace)
 
-        buffer_event(
+        # Bypasses the cap: the exception is the event a capped request most needs.
+        thread_event_buffer << {
           name: "EXCEPTION: #{exception.class.name}",
           severity: 'error',
           category: 'exception',
@@ -65,13 +66,56 @@ module EventTimeline
           },
           correlation_id: correlation_id,
           occurred_at: Time.current
-        )
+        }
       rescue StandardError => e
         Rails.logger.error "EventTimeline exception recording failed: #{e.message}" if defined?(Rails.logger)
       end
 
       private
 
+      # Classes loaded or reloaded after boot are attached and detached as Zeitwerk loads them.
+      def register_autoload_hooks
+        return if @autoload_hooks_registered || !defined?(Rails.autoloaders)
+
+        @autoload_hooks_registered = true
+        Rails.autoloaders.main.on_load do |_cpath, value, _abspath|
+          attach(value) if installed? && value.is_a?(Module)
+        end
+        Rails.autoloaders.main.on_unload { |_cpath, value, _abspath| detach(value) if installed? }
+      end
+
+      # Rails' deprecated constant proxies print a warning on almost any method call, is_a? included.
+      def deprecated_constant?(mod)
+        defined?(ActiveSupport::Deprecation::DeprecatedConstantProxy) &&
+          Kernel.instance_method(:is_a?).bind_call(mod, ActiveSupport::Deprecation::DeprecatedConstantProxy)
+      end
+
+      def attach(mod)
+        return if @traces.nil? || @traces.key?(mod)
+
+        @traces[mod] = watched_methods(mod).map do |method|
+          TracePoint.new(:call, :return) { |tp| tp.event == :call ? handle_call(tp) : handle_return(tp) }
+                    .tap { |trace| trace.enable(target: method) }
+        end
+      end
+
+      def detach(mod)
+        @traces&.delete(mod)&.each(&:disable)
+      end
+
+      # Attr methods have no Ruby body to target, and aliases share one, so each body is traced once.
+      def watched_methods(mod)
+        [mod, mod.singleton_class].flat_map { |owner| own_methods(owner) }.uniq.select do |method|
+          RubyVM::InstructionSequence.of(method) && EventTimeline.configuration&.watched?(method.source_location&.first)
+        end
+      end
+
+      def own_methods(owner)
+        names = owner.instance_methods(false) + owner.private_instance_methods(false) +
+                owner.protected_instance_methods(false)
+        names.map { |name| owner.instance_method(name) }
+      end
+
       def clean_backtrace(backtrace)
         # Filter out gem internals, keep app code
         backtrace.reject { |line| line.include?('/gems/') || line.include?('/ruby/') }
@@ -89,44 +133,43 @@ module EventTimeline
       end
 
       def handle_call(tp)
-        return unless EventTimeline.configuration&.watched?(tp.path)
+        correlation_id = CurrentCorrelation.id
+        return unless correlation_id
 
-        correlation_id = CurrentCorrelation.id || determine_correlation_id
-        event_id = SecureRandom.uuid
+        event_id = next_event_id
+        signature = method_signature(tp)
 
-        push_to_stack(correlation_id, event_id, tp)
-        buffer_call_event(correlation_id, event_id, tp)
+        push_to_stack(correlation_id, event_id, signature)
+        buffer_call_event(correlation_id, event_id, signature, tp)
       rescue StandardError => e
         Rails.logger.error "EventTimeline call tracking failed: #{e.message}" if defined?(Rails.logger)
       end
 
       def handle_return(tp)
-        # Skip watched? check - if we didn't track the call, pop_from_stack returns nil
         correlation_id = CurrentCorrelation.id
         return unless correlation_id
 
-        method_info = pop_from_stack(correlation_id, tp)
+        signature = method_signature(tp)
+        method_info = pop_from_stack(correlation_id, signature)
         return unless method_info
 
-        buffer_return_event(correlation_id, method_info, tp)
+        buffer_return_event(correlation_id, method_info, signature, tp)
       rescue StandardError => e
         Rails.logger.error "EventTimeline return tracking failed: #{e.message}" if defined?(Rails.logger)
       end
 
-      def push_to_stack(correlation_id, event_id, tp)
+      def push_to_stack(correlation_id, event_id, signature)
         stack = thread_method_stack[correlation_id] ||= []
         stack.push(
           event_id: event_id,
-          method: method_signature(tp)
+          method: signature
         )
       end
 
-      def pop_from_stack(correlation_id, tp)
+      def pop_from_stack(correlation_id, signature)
         stack = thread_method_stack[correlation_id]
         return unless stack
 
-        signature = method_signature(tp)
-
         # Find the LAST matching entry (proper LIFO for recursion)
         index = stack.rindex { |m| m[:method] == signature }
         return unless index
@@ -138,9 +181,9 @@ module EventTimeline
         "#{tp.defined_class}##{tp.method_id}"
       end
 
-      def buffer_call_event(correlation_id, event_id, tp)
+      def buffer_call_event(correlation_id, event_id, signature, tp)
         buffer_event(
-          name: method_signature(tp),
+          name: signature,
           severity: 'info',
           category: 'method_call',
           payload: {
@@ -152,13 +195,13 @@ module EventTimeline
             params: capture_params(tp)
           },
           correlation_id: correlation_id,
-          occurred_at: Time.current
+          occurred_at: Time.now
         )
       end
 
-      def buffer_return_event(correlation_id, method_info, tp)
+      def buffer_return_event(correlation_id, method_info, signature, tp)
         buffer_event(
-          name: "#{method_signature(tp)}_return",
+          name: "#{signature}_return",
           severity: 'info',
           category: 'method_return',
           payload: {
@@ -168,7 +211,7 @@ module EventTimeline
             method: tp.method_id.to_s
           },
           correlation_id: correlation_id,
-          occurred_at: Time.current
+          occurred_at: Time.now
         )
       end
 
@@ -180,15 +223,26 @@ module EventTimeline
         Thread.current[THREAD_KEY_EVENT_BUFFER] ||= []
       end
 
+      def next_event_id
+        Thread.current[THREAD_KEY_EVENT_SEQUENCE] = (Thread.current[THREAD_KEY_EVENT_SEQUENCE] || 0) + 1
+      end
+
+      # Past the per-request cap, keep the earliest events and mark the cut once.
       def buffer_event(event)
-        thread_event_buffer << event
+        buffer = thread_event_buffer
+        limit = EventTimeline.configuration&.max_events_per_correlation
+        if limit.nil? || buffer.size < limit
+          buffer << event
+        elsif buffer.size == limit
+          buffer << { name: 'EVENTS TRUNCATED', severity: 'warn', category: 'truncated', payload: { limit: limit },
+                      correlation_id: event[:correlation_id], occurred_at: event[:occurred_at] }
+        end
       end
 
       def capture_params(tp)
-        method = tp.self.method(tp.method_id)
         params = {}
 
-        method.parameters.each do |_type, name|
+        tp.parameters.each do |_type, name|
           next unless name
 
           if tp.binding.local_variable_defined?(name)
@@ -201,16 +255,6 @@ module EventTimeline
       rescue StandardError => e
         { error: "Failed to capture params: #{e.message}" }
       end
-
-      def determine_correlation_id
-        if Thread.current[:request_id]
-          Thread.current[:request_id]
-        elsif Thread.current[:active_job_id]
-          Thread.current[:active_job_id]
-        else
-          SecureRandom.uuid.tap { |id| CurrentCorrelation.id = id }
-        end
-      end
     end
   end
 end

data/lib/event_timeline/rotation_service.rb

@@ -24,41 +24,8 @@ module EventTimeline
         perform_cleanup(total_count, max_total)
       end
 
-      def enforce_correlation_limit(correlation_id, buffer_size = 0, force: false)
-        return unless EventTimeline.configuration
-
-        max_per_correlation = EventTimeline.configuration.max_events_per_correlation
-
-        unless force
-          # Track in-memory counts to avoid DB query on every flush
-          @correlation_counts ||= {}
-          @correlation_counts[correlation_id] ||= 0
-          @correlation_counts[correlation_id] += buffer_size
-
-          # Only hit DB when we think we might be near the limit
-          return unless @correlation_counts[correlation_id] >= (max_per_correlation * 0.9)
-        end
-
-        current_count = Session.where(correlation_id: correlation_id).count
-        @correlation_counts[correlation_id] = current_count if @correlation_counts # Sync with reality
-
-        return unless current_count >= max_per_correlation
-
-        # Remove oldest events for this correlation, keeping last 80%
-        keep_count = (max_per_correlation * 0.8).to_i
-        oldest_events = Session.where(correlation_id: correlation_id)
-                               .order(:occurred_at)
-                               .limit(current_count - keep_count)
-
-        Session.where(id: oldest_events.pluck(:id)).delete_all
-        @correlation_counts[correlation_id] = keep_count if @correlation_counts
-
-        Rails.logger.info "EventTimeline: Rotated #{current_count - keep_count} events for correlation #{correlation_id}" if defined?(Rails.logger)
-      end
-
       def reset_counters!
         @flush_counter = 0
-        @correlation_counts = {}
       end
 
       private

data/lib/event_timeline/value_inspector.rb

@@ -46,8 +46,12 @@ module EventTimeline
 
       def inspect_collection(value)
         max_length = EventTimeline.configuration&.max_inspect_length || 200
+        summary = "#{value.class}[#{value.size} items]"
+        # More items than characters allowed can never inspect short enough, so skip the inspect.
+        return summary if value.size > max_length
+
         inspected = value.inspect
-        inspected.length > max_length ? "#{value.class}[#{value.size} items]" : inspected
+        inspected.length > max_length ? summary : inspected
       end
 
       def inspect_activemodel(model)
@@ -57,6 +61,11 @@ module EventTimeline
       end
 
       def inspect_generic(value)
+        # Relation#inspect runs a query.
+        if defined?(ActiveRecord::Relation) && value.is_a?(ActiveRecord::Relation)
+          return "#{value.klass.name}::Relation"
+        end
+
         max_length = EventTimeline.configuration&.max_inspect_length || 200
         result = value.inspect
         result.length > max_length ? "#{value.class.name}[#{result.length} chars]" : result

data/lib/event_timeline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EventTimeline
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: event_timeline
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - svn-arv
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -89,7 +88,6 @@ homepage: https://github.com/svn-arv/event_timeline
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,8 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Debug Rails apps by replaying method calls from any request
 test_files: []