event_timeline 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: acfe8f6da4ca9044255ba5db0c60ea66e6aaedfebd3b9c47a36eb2ace19631f6
+  data.tar.gz: 9659ba87a4dd38ac503ddb6ee5573fb6088789240472e4e9f4cbe2ff0e063983
+SHA512:
+  metadata.gz: 2d4e4efbc26ca24019666469a1d64d2f183f7c2264a0aecef97d61913fe018299f7fac4d00fa6e37d15f7fb39b064cd90d344bc02ba60f2e33460e309e4a3f42
+  data.tar.gz: fab0b6ee70307348d2513ade4988e94bbe1abaca374bcac8ea5b6b64a4f14519ac8bfe226841e047f3cdbc3e5c8a066b834e818abea6d5d1ca6b1662de97c1c2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright svn-arv
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# EventTimeline
+
+Ever wished you could replay what happened during a request? EventTimeline tracks method calls in your Rails app so you can see exactly how your code executed.
+
+## What it does
+
+EventTimeline records method calls and returns as they happen, letting you:
+
+- See the exact sequence of method calls during a request
+- Inspect parameters passed to each method
+- View return values
+- Track execution flow across multiple services
+- Debug production issues by replaying what actually happened
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'event_timeline'
+```
+
+Then:
+
+```bash
+bundle install
+rails generate event_timeline:install
+rails db:migrate
+```
+
+## Basic Usage
+
+### 1. Configure what to track
+
+```ruby
+# config/initializers/event_timeline.rb
+EventTimeline.configure do |config|
+  # Track specific paths
+  config.watch 'app/services'
+  config.watch 'app/models/order.rb'
+  config.watch 'lib/payment_processor'
+end
+```
+
+### 2. View the timeline
+
+Visit `/event_timeline/sessions/:request_id` to see what happened during any request.
+
+Example: Your logs show request ID `abc-123-def` failed? Go to `/event_timeline/sessions/abc-123-def` and see every method that was called.
+
+## Real-world Example
+
+Let's say a payment fails in production. Here's what you'd see:
+
+```
+OrdersController#create
+  Order#initialize
+    Order#validate_items
+    Order#calculate_total
+  Order#save
+  PaymentService#charge
+    PaymentGateway#create_charge
+      <- Returns: {error: "Insufficient funds"}
+    PaymentService#handle_failure
+      Order#mark_as_failed
+      CustomerMailer#payment_failed
+```
+
+Now you know exactly where things went wrong and what data was involved.
+
+## Configuration Options
+
+```ruby
+EventTimeline.configure do |config|
+  # Filter sensitive data
+  config.add_filtered_attributes :credit_card, :ssn, :api_key
+
+  # Custom PII filtering
+  config.filter_pii do |key, value|
+    return '<REDACTED>' if key.to_s =~ /bank_account/
+  end
+
+  # Customize how events are described
+  config.narrator do |event|
+    case event.name
+    when /Stripe/
+      "[PAYMENT] #{event.name}"
+    else
+      event.name
+    end
+  end
+
+  # Data retention (defaults shown)
+  config.max_events_per_correlation = 500     # Per request
+  config.max_total_events = 10_000            # Total stored
+  config.max_event_age = 1.month              # Auto-delete after
+end
+```
+
+## Performance
+
+EventTimeline uses TracePoint which has minimal overhead. Data is automatically rotated to prevent unbounded growth:
+
+- Old events are deleted after 1 month
+- Per-request events are capped at 500
+- Total events are capped at 10,000
+
+## Pro Tips
+
+1. **Production Debugging**: When users report issues, ask for their request ID from the logs. EventTimeline will show you exactly what happened.
+
+2. **Development**: Watch your code execute in real-time. Great for understanding unfamiliar codebases.
+
+3. **Testing**: Verify your code follows the expected execution path.
+
+4. **Correlation IDs**: EventTimeline automatically groups events by request ID, but you can set custom correlation IDs:
+   ```ruby
+   EventTimeline::CurrentCorrelation.id = "import-job-#{job.id}"
+   ```
+
+## Limitations
+
+- Only tracks Ruby method calls (not database queries or external HTTP calls)
+- TracePoint doesn't work with some metaprogramming techniques
+- Large payloads are truncated to keep storage reasonable
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'bundler/gem_tasks'

data/app/controllers/event_timeline/application_controller.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/event_timeline/sessions_controller.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class SessionsController < ApplicationController
+    def show
+      @correlation_id = params[:id]
+      @events = Session.by_correlation(@correlation_id)
+    end
+  end
+end

data/app/helpers/event_timeline/application_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  module ApplicationHelper
+    def narrate_event(event)
+      if EventTimeline.configuration&.narrator_proc
+        EventTimeline.configuration.narrator_proc.call(event)
+      else
+        event.name.humanize
+      end
+    end
+  end
+end

data/app/models/event_timeline/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/event_timeline/session.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class Session < ApplicationRecord
+    self.table_name = 'event_timeline_sessions'
+
+    validates :name, presence: true
+    validates :correlation_id, presence: true
+    validates :occurred_at, presence: true
+
+    scope :by_correlation, ->(id) { where(correlation_id: id).order(occurred_at: :asc) }
+  end
+end

data/app/views/event_timeline/sessions/show.html.erb

@@ -0,0 +1,46 @@
+<div class="container">
+  <h1>Timeline for <span class="correlation-id"><%= @correlation_id %></span></h1>
+
+  <div class="timeline">
+    <% @events.each do |event| %>
+      <% is_return = event.category == "method_return" %>
+      <div class="event <%= event.severity %> <%= 'return' if is_return %>">
+        <div class="event-header">
+          <span class="event-name">
+            <% if is_return %>
+              &lt;- <%= event.name.gsub('_return', '') %>
+            <% else %>
+              <%= narrate_event(event) %>
+            <% end %>
+          </span>
+          <span class="event-time"><%= event.occurred_at.strftime("%H:%M:%S.%L") %></span>
+        </div>
+
+        <% if event.payload.present? %>
+          <% if is_return %>
+            <div style="font-size: 14px; color: #059862;">
+              Returns: <%= event.payload['return_value'] %>
+            </div>
+          <% elsif event.payload['params'].present? && !event.payload['params'].empty? %>
+            <div style="font-size: 14px; color: #0066cc;">
+              Params: <%= event.payload['params'].inspect %>
+            </div>
+          <% end %>
+          
+          <details>
+            <summary>Show full payload</summary>
+            <div class="event-payload">
+              <%= JSON.pretty_generate(event.payload) %>
+            </div>
+          </details>
+        <% end %>
+      </div>
+    <% end %>
+
+    <% if @events.empty? %>
+      <p style="color: #6c757d; text-align: center; padding: 40px 0;">
+        No events found for this correlation ID
+      </p>
+    <% end %>
+  </div>
+</div>

data/app/views/layouts/event_timeline/application.html.erb

@@ -0,0 +1,117 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>EventTimeline</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      margin: 0;
+      padding: 20px;
+      background: #f5f5f5;
+    }
+    .container {
+      max-width: 800px;
+      margin: 0 auto;
+      background: white;
+      padding: 20px;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    h1 {
+      margin: 0 0 20px 0;
+      font-size: 24px;
+      color: #333;
+    }
+    .timeline {
+      position: relative;
+      padding-left: 30px;
+    }
+    .timeline::before {
+      content: '';
+      position: absolute;
+      left: 10px;
+      top: 0;
+      bottom: 0;
+      width: 2px;
+      background: #ddd;
+    }
+    .event {
+      position: relative;
+      margin-bottom: 20px;
+      padding: 15px;
+      background: #f8f9fa;
+      border-radius: 6px;
+      border: 1px solid #e9ecef;
+    }
+    .event::before {
+      content: '';
+      position: absolute;
+      left: -25px;
+      top: 20px;
+      width: 10px;
+      height: 10px;
+      background: white;
+      border: 2px solid #ddd;
+      border-radius: 50%;
+    }
+    .event.error::before {
+      background: #dc3545;
+      border-color: #dc3545;
+    }
+    .event.warning::before {
+      background: #ffc107;
+      border-color: #ffc107;
+    }
+    .event.info::before {
+      background: #0dcaf0;
+      border-color: #0dcaf0;
+    }
+    .event.return::before {
+      background: #059862;
+      border-color: #059862;
+    }
+    .event-header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      margin-bottom: 8px;
+    }
+    .event-name {
+      font-weight: 600;
+      color: #212529;
+    }
+    .event-time {
+      font-size: 14px;
+      color: #6c757d;
+    }
+    .event-payload {
+      margin-top: 10px;
+      padding: 10px;
+      background: white;
+      border-radius: 4px;
+      font-family: monospace;
+      font-size: 13px;
+      overflow-x: auto;
+    }
+    details summary {
+      cursor: pointer;
+      color: #0066cc;
+      font-size: 14px;
+    }
+    .correlation-id {
+      font-family: monospace;
+      background: #e9ecef;
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-size: 14px;
+    }
+  </style>
+</head>
+
+<body>
+  <%= yield %>
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+EventTimeline::Engine.routes.draw do
+  resources :sessions, only: [:show]
+end

data/db/migrate/20260103180115_create_event_timeline_sessions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateEventTimelineSessions < ActiveRecord::Migration[8.1]
+  def change
+    create_table :event_timeline_sessions do |t|
+      t.string :name, null: false
+      t.string :severity, default: 'info'
+      t.string :category
+      t.jsonb :payload
+      t.string :correlation_id, null: false
+      t.datetime :occurred_at, null: false
+
+      t.timestamps
+    end
+
+    add_index :event_timeline_sessions, :correlation_id
+    add_index :event_timeline_sessions, :occurred_at
+    add_index :event_timeline_sessions, %i[correlation_id occurred_at]
+  end
+end

data/lib/event_timeline/call_tracker.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class CallTracker
+    class << self
+      def install!
+        @last_location = {}
+        @method_stack = Hash.new { |h, k| h[k] = [] }
+
+        call_trace = TracePoint.new(:call) do |tp|
+          next unless EventTimeline.configuration&.watched?(tp.path)
+
+          current_location = "#{tp.path}:#{tp.lineno}"
+          correlation_id = CurrentCorrelation.id || determine_correlation_id
+
+          if @last_location[correlation_id] != current_location
+            @last_location[correlation_id] = current_location
+
+            # Capture method arguments
+            params = capture_params(tp)
+
+            event_id = SecureRandom.uuid
+            @method_stack[correlation_id].push({
+                                                 event_id: event_id,
+                                                 method: "#{tp.defined_class}##{tp.method_id}"
+                                               })
+
+            Session.create!(
+              name: "#{tp.defined_class}##{tp.method_id}",
+              severity: 'info',
+              category: 'method_call',
+              payload: {
+                event_id: event_id,
+                file: tp.path,
+                line: tp.lineno,
+                class: tp.defined_class.to_s,
+                method: tp.method_id.to_s,
+                params: params
+              },
+              correlation_id: correlation_id,
+              occurred_at: Time.current
+            )
+
+            # Enforce rotation limits
+            RotationService.enforce_correlation_limit(correlation_id)
+            RotationService.cleanup_if_needed
+          end
+        rescue StandardError => e
+          Rails.logger.error "EventTimeline call tracking failed: #{e.message}" if defined?(Rails.logger)
+        end
+
+        return_trace = TracePoint.new(:return) do |tp|
+          next unless EventTimeline.configuration&.watched?(tp.path)
+
+          correlation_id = CurrentCorrelation.id || determine_correlation_id
+          method_info = @method_stack[correlation_id].find { |m| m[:method] == "#{tp.defined_class}##{tp.method_id}" }
+
+          if method_info
+            @method_stack[correlation_id].delete(method_info)
+
+            Session.create!(
+              name: "#{tp.defined_class}##{tp.method_id}_return",
+              severity: 'info',
+              category: 'method_return',
+              payload: {
+                event_id: method_info[:event_id],
+                return_value: filter_sensitive_data(:return_value, tp.return_value, { context: :return_value }),
+                class: tp.defined_class.to_s,
+                method: tp.method_id.to_s
+              },
+              correlation_id: correlation_id,
+              occurred_at: Time.current
+            )
+          end
+        rescue StandardError => e
+          Rails.logger.error "EventTimeline return tracking failed: #{e.message}" if defined?(Rails.logger)
+        end
+
+        call_trace.enable
+        return_trace.enable
+      end
+
+      private
+
+      def capture_params(tp)
+        method = tp.self.method(tp.method_id)
+        params = {}
+
+        method.parameters.each_value do |name|
+          if tp.binding.local_variable_defined?(name)
+            value = tp.binding.local_variable_get(name)
+            params[name] = filter_sensitive_data(name, value, { context: :parameter })
+          end
+        end
+
+        params
+      rescue StandardError => e
+        { error: "Failed to capture params: #{e.message}" }
+      end
+
+      def safe_inspect(value)
+        case value
+        when String
+          value.length > 100 ? "#{value[0..100]}..." : value
+        when Hash, Array
+          value.inspect.length > 200 ? "#{value.class}[#{value.size} items]" : value.inspect
+        when defined?(ActiveRecord::Base) && ActiveRecord::Base
+          inspect_activerecord(value)
+        when defined?(ActiveModel::Model) && ActiveModel::Model
+          inspect_model(value)
+        when Class
+          value.name
+        when Module
+          value.name
+        else
+          simple_inspect(value)
+        end
+      rescue StandardError => e
+        "<inspect failed: #{e.message}>"
+      end
+
+      def inspect_activerecord(record)
+        if record.persisted?
+          id_attr = record.class.primary_key
+          id_value = record.send(id_attr) if id_attr
+          "#{record.class.name}(#{id_attr}: #{id_value})"
+        else
+          "#{record.class.name}(new_record)"
+        end
+      rescue StandardError => e
+        "#{record.class.name}(<inspection failed>)"
+      end
+
+      def inspect_model(model)
+        "#{model.class.name}(#{model.class.attribute_names.size} attributes)"
+      rescue StandardError => e
+        "#{model.class.name}(<inspection failed>)"
+      end
+
+      def simple_inspect(value)
+        result = value.inspect
+        if result.length > 200
+          "#{value.class.name}[#{result.length} chars]"
+        else
+          result
+        end
+      end
+
+      def filter_sensitive_data(key, value, context = {})
+        if EventTimeline.configuration&.should_filter?(key, value, context)
+          case value
+          when String
+            '<FILTERED>'
+          when Hash
+            filter_hash(value)
+          when Array
+            value.map.with_index { |item, index| filter_sensitive_data("item_#{index}", item, context) }
+          when defined?(ActiveRecord::Base) && ActiveRecord::Base
+            filter_activerecord(value)
+          else
+            '<FILTERED>'
+          end
+        else
+          safe_inspect(value)
+        end
+      end
+
+      def filter_hash(hash)
+        filtered = {}
+        hash.each do |key, value|
+          filtered[key] = filter_sensitive_data(key, value, { context: :hash_value })
+        end
+        filtered
+      end
+
+      def filter_activerecord(record)
+        if EventTimeline.configuration&.should_filter?(:activerecord, record, { context: :model })
+          '<FILTERED>'
+        else
+          # Show model with filtered attributes
+          filtered_attrs = {}
+          record.attributes.each do |key, value|
+            filtered_attrs[key] = if EventTimeline.configuration&.should_filter?(key, value, { context: :attribute })
+                                    '<FILTERED>'
+                                  else
+                                    safe_inspect(value)
+                                  end
+          end
+          "#{inspect_activerecord(record)} {#{filtered_attrs.map { |k, v| "#{k}: #{v}" }.join(', ')}}"
+        end
+      rescue StandardError => e
+        "#{inspect_activerecord(record)} <filtering failed>"
+      end
+
+      def determine_correlation_id
+        if Thread.current[:request_id]
+          Thread.current[:request_id]
+        elsif defined?(ActiveJob::Base) && ActiveJob::Base.current_execution&.job_id
+          ActiveJob::Base.current_execution.job_id
+        else
+          SecureRandom.uuid.tap { |id| CurrentCorrelation.id = id }
+        end
+      end
+    end
+  end
+end

data/lib/event_timeline/configuration.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class Configuration
+    attr_accessor :narrator_proc, :watched_paths, :pii_filter_proc, :filtered_attributes,
+                  :max_events_per_correlation, :max_total_events, :cleanup_threshold, :max_event_age
+
+    def initialize
+      @watched_paths = []
+      @filtered_attributes = default_filtered_attributes
+      @max_events_per_correlation = 500 # Max events per correlation_id
+      @max_total_events = 10_000 # Max total events before cleanup
+      @cleanup_threshold = 0.8           # Start cleanup at 80% of max
+      @max_event_age = 1.month           # Delete events older than this
+    end
+
+    def narrator(&block)
+      @narrator_proc = block if block_given?
+    end
+
+    def watch(path)
+      @watched_paths << normalize_path(path)
+    end
+
+    def watched?(file_path)
+      return false if @watched_paths.empty?
+
+      @watched_paths.any? do |pattern|
+        File.fnmatch?(pattern, file_path, File::FNM_PATHNAME)
+      end
+    end
+
+    def filter_pii(&block)
+      @pii_filter_proc = block if block_given?
+    end
+
+    def add_filtered_attributes(*attrs)
+      @filtered_attributes.concat(attrs.map(&:to_s))
+    end
+
+    def remove_filtered_attributes(*attrs)
+      attrs.each { |attr| @filtered_attributes.delete(attr.to_s) }
+    end
+
+    def should_filter?(key, value, context = {})
+      key_str = key.to_s.downcase
+
+      # Check custom filter first
+      if @pii_filter_proc
+        result = @pii_filter_proc.call(key, value, context)
+        return result unless result.nil?
+      end
+
+      # Default filtering logic
+      @filtered_attributes.any? { |attr| key_str.include?(attr) }
+    end
+
+    private
+
+    def default_filtered_attributes
+      %w[
+        password
+        token
+        secret
+        key
+        credential
+        auth
+        session
+        cookie
+        ssn
+        social_security
+        credit_card
+        card_number
+        cvv
+        pin
+        private
+        confidential
+      ]
+    end
+
+    def normalize_path(path)
+      path = path.to_s
+      path = "#{Rails.root}/#{path}" unless path.start_with?('/')
+      "#{path.gsub(%r{/$}, '')}/**/*.rb" unless path.include?('*')
+    end
+  end
+end

data/lib/event_timeline/current_correlation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class CurrentCorrelation < ActiveSupport::CurrentAttributes
+    attribute :id
+  end
+end

data/lib/event_timeline/engine.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class Engine < ::Rails::Engine
+    isolate_namespace EventTimeline
+
+    initializer 'timeline.install_call_tracker' do
+      ActiveSupport.on_load(:after_initialize) do
+        EventTimeline::CallTracker.install!
+      end
+    end
+
+    initializer 'timeline.setup_middleware' do |app|
+      app.middleware.use EventTimeline::Middleware
+    end
+  end
+end

data/lib/event_timeline/middleware.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+      CurrentCorrelation.id = request.request_id
+      Thread.current[:request_id] = request.request_id
+
+      @app.call(env)
+    ensure
+      CurrentCorrelation.reset
+      Thread.current[:request_id] = nil
+    end
+  end
+end

data/lib/event_timeline/rotation_service.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module EventTimeline
+  class RotationService
+    class << self
+      def cleanup_if_needed
+        return unless EventTimeline.configuration
+
+        total_count = Session.count
+        max_total = EventTimeline.configuration.max_total_events
+        threshold = (max_total * EventTimeline.configuration.cleanup_threshold).to_i
+
+        return unless total_count >= threshold
+
+        perform_cleanup(total_count, max_total)
+      end
+
+      def enforce_correlation_limit(correlation_id)
+        return unless EventTimeline.configuration
+
+        max_per_correlation = EventTimeline.configuration.max_events_per_correlation
+        current_count = Session.where(correlation_id: correlation_id).count
+
+        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
+
+        Rails.logger.info "EventTimeline: Rotated #{current_count - keep_count} events for correlation #{correlation_id}" if defined?(Rails.logger)
+      end
+
+      private
+
+      def perform_cleanup(current_count, max_count)
+        # Calculate how many events to remove
+        target_count = (max_count * 0.7).to_i # Remove down to 70% of max
+        events_to_remove = current_count - target_count
+
+        # Remove oldest events first
+        oldest_events = Session.order(:occurred_at).limit(events_to_remove)
+        Session.where(id: oldest_events.pluck(:id)).delete_all
+
+        # Also clean up very old events based on configured age
+        max_age = EventTimeline.configuration.max_event_age
+        cutoff_date = max_age.ago
+        old_events_count = Session.where('occurred_at < ?', cutoff_date).delete_all
+
+        Rails.logger.info "EventTimeline: Cleaned up #{events_to_remove + old_events_count} events" if defined?(Rails.logger)
+      end
+    end
+  end
+end

data/lib/event_timeline/version.rb

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

data/lib/event_timeline.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'event_timeline/version'
+require 'event_timeline/engine'
+require 'event_timeline/configuration'
+require 'event_timeline/current_correlation'
+require 'event_timeline/call_tracker'
+require 'event_timeline/middleware'
+require 'event_timeline/rotation_service'
+
+module EventTimeline
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    alias config configure
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: event_timeline
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- svn-arv
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: EventTimeline tracks method calls in your Rails app so you can replay
+  and debug what happened during any request. Perfect for understanding production
+  issues and unfamiliar codebases.
+email:
+- svn-arv@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/event_timeline/application_controller.rb
+- app/controllers/event_timeline/sessions_controller.rb
+- app/helpers/event_timeline/application_helper.rb
+- app/models/event_timeline/application_record.rb
+- app/models/event_timeline/session.rb
+- app/views/event_timeline/sessions/show.html.erb
+- app/views/layouts/event_timeline/application.html.erb
+- config/routes.rb
+- db/migrate/20260103180115_create_event_timeline_sessions.rb
+- lib/event_timeline.rb
+- lib/event_timeline/call_tracker.rb
+- lib/event_timeline/configuration.rb
+- lib/event_timeline/current_correlation.rb
+- lib/event_timeline/engine.rb
+- lib/event_timeline/middleware.rb
+- lib/event_timeline/rotation_service.rb
+- lib/event_timeline/version.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Debug Rails apps by replaying method calls from any request
+test_files: []