rails_event_viewer 0.1.0

data/lib/rails_event_viewer/subscriber.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module RailsEventViewer
+  class Subscriber
+    NANOSECONDS_PER_SECOND = 1_000_000_000.0
+    SHUTDOWN_TIMEOUT_SECONDS = 5
+    ACTION_CABLE_CHANNEL = "rails_event_viewer:events"
+
+    def initialize
+      @buffer = Queue.new
+      @mutex = Mutex.new
+      @flusher_thread = nil
+      @shutdown_requested = false
+      @pid = Process.pid
+
+      ensure_flusher_thread!
+    end
+
+    def emit(event)
+      handle_fork_if_needed
+
+      return unless should_capture?(event)
+      return if sampled_out?
+
+      entry = build_entry(event)
+
+      if RailsEventViewer.async
+        buffer_event(entry)
+      else
+        write_immediately([entry])
+      end
+    rescue => e
+      handle_error(e, event)
+    end
+
+    def flush!
+      return if @buffer.empty?
+
+      events_to_write = drain_buffer
+
+      return if events_to_write.empty?
+
+      write_immediately(events_to_write)
+      broadcast_events(events_to_write)
+    end
+
+    def stop!
+      @mutex.synchronize do
+        @shutdown_requested = true
+      end
+
+      if @flusher_thread&.alive?
+        @flusher_thread.wakeup rescue nil
+        @flusher_thread.join(SHUTDOWN_TIMEOUT_SECONDS)
+      end
+
+      @mutex.synchronize do
+        @flusher_thread = nil
+      end
+
+      flush!
+    end
+
+    def running?
+      @flusher_thread&.alive? || false
+    end
+
+    def buffer_size
+      @buffer.size
+    end
+
+    private
+
+    def handle_fork_if_needed
+      # Threads don't survive forks, so we need to restart the flusher
+      @mutex.synchronize do
+        if @pid != Process.pid
+          @pid = Process.pid
+          @buffer = Queue.new
+          @flusher_thread = nil
+          @shutdown_requested = false
+        end
+      end
+      ensure_flusher_thread!
+    end
+
+    def drain_buffer
+      events = []
+      loop { events << @buffer.pop(true) }
+    rescue ThreadError
+      events
+    end
+
+    def buffer_event(entry)
+      @buffer << entry
+      ensure_flusher_thread!
+
+      flush! if @buffer.size >= RailsEventViewer.buffer_size
+    end
+
+    def ensure_flusher_thread!
+      return unless RailsEventViewer.async
+
+      @mutex.synchronize do
+        return if @flusher_thread&.alive?
+        return if @shutdown_requested
+
+        @flusher_thread = Thread.new { run_flusher_loop }
+      end
+    end
+
+    def run_flusher_loop
+      log_info("[RailsEventViewer] Flusher thread started (PID: #{Process.pid})")
+
+      until shutdown_requested?
+        begin
+          sleep(RailsEventViewer.flush_interval)
+          flush! unless @buffer.empty?
+        rescue => e
+          log_error("[RailsEventViewer] Flusher error: #{e.message}")
+        end
+      end
+
+      log_info("[RailsEventViewer] Flusher thread stopped (PID: #{Process.pid})")
+    end
+
+    def shutdown_requested?
+      @mutex.synchronize { @shutdown_requested }
+    end
+
+    def write_immediately(events)
+      return if events.blank?
+
+      RailsEventViewer.adapter.write_events(events)
+    rescue => e
+      log_error("[RailsEventViewer] Failed to write #{events.size} events: #{e.message}")
+    end
+
+    def broadcast_events(events)
+      return unless defined?(ActionCable)
+      return unless events.any?
+
+      ActionCable.server.broadcast(
+        ACTION_CABLE_CHANNEL,
+        {
+          action: "new_events",
+          count: events.size,
+          events: events.map { |e| { name: e[:name], occurred_at: e[:occurred_at]&.iso8601 } }
+        }
+      )
+    rescue => e
+      log_error("[RailsEventViewer] Broadcast error: #{e.message}")
+    end
+
+    def should_capture?(event)
+      return false unless event.is_a?(Hash)
+      return false if event[:name].blank?
+
+      name = event[:name].to_s
+      return false if ignored?(name)
+      return true if RailsEventViewer.captured_events.empty?
+
+      captured?(name)
+    end
+
+    def ignored?(name)
+      RailsEventViewer.ignored_events.any? do |pattern|
+        matches_pattern?(name, pattern)
+      end
+    end
+
+    def captured?(name)
+      RailsEventViewer.captured_events.any? do |pattern|
+        matches_pattern?(name, pattern)
+      end
+    end
+
+    def matches_pattern?(name, pattern)
+      case pattern
+      when String
+        name == pattern
+      when Regexp
+        name.match?(pattern)
+      else
+        false
+      end
+    end
+
+    def sampled_out?
+      rate = RailsEventViewer.sample_rate
+      return false if rate >= 1.0
+
+      rand > rate
+    end
+
+    def build_entry(event)
+      timestamp = event[:timestamp]
+      occurred_at = if timestamp
+        Time.at(timestamp / NANOSECONDS_PER_SECOND)
+      else
+        Time.current
+      end
+
+      {
+        name: event[:name],
+        payload: serialize_payload(event[:payload]),
+        tags: event[:tags] || {},
+        context: event[:context] || {},
+        source_file: event.dig(:source_location, :filepath),
+        source_line: event.dig(:source_location, :lineno),
+        source_label: event.dig(:source_location, :label),
+        occurred_at: occurred_at
+      }
+    end
+
+    def serialize_payload(payload)
+      case payload
+      when Hash
+        payload
+      when nil
+        {}
+      else
+        if payload.respond_to?(:to_h)
+          payload.to_h
+        elsif payload.respond_to?(:as_json)
+          payload.as_json
+        else
+          { value: payload.to_s }
+        end
+      end
+    end
+
+    def handle_error(error, event)
+      log_error("[RailsEventViewer] Failed to capture event '#{event[:name]}': #{error.message}")
+    end
+
+    def log_info(message)
+      effective_logger&.info(message)
+    end
+
+    def log_error(message)
+      logger = effective_logger
+
+      if logger
+        logger.error(message)
+      else
+        warn message
+      end
+    end
+
+    def effective_logger
+      RailsEventViewer.logger || (defined?(Rails) && Rails.logger)
+    end
+  end
+end

data/lib/rails_event_viewer/time_utils.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsEventViewer
+  module TimeUtils
+    module_function
+
+    def truncate_to_interval(time, interval)
+      return nil unless time
+
+      case interval
+      when :minute
+        time.beginning_of_minute
+      when :hour
+        time.beginning_of_hour
+      when :day
+        time.beginning_of_day
+      when :week
+        time.beginning_of_week
+      else
+        time.beginning_of_hour
+      end
+    end
+  end
+end

data/lib/rails_event_viewer/version.rb

@@ -0,0 +1,3 @@
+module RailsEventViewer
+  VERSION = "0.1.0"
+end

data/lib/rails_event_viewer.rb

@@ -0,0 +1,122 @@
+require "pagy"
+require "chartkick"
+require "groupdate"
+
+require "rails_event_viewer/version"
+require "rails_event_viewer/engine"
+
+module RailsEventViewer
+  mattr_accessor :storage_adapter, default: :active_record
+  mattr_accessor :adapter_options, default: {}
+
+  mattr_accessor :async, default: true # Use buffered writes
+  mattr_accessor :buffer_size, default: 100 # Flush after N events
+  mattr_accessor :flush_interval, default: 2 # Flush every N seconds
+  mattr_accessor :sample_rate, default: 1.0 # 1.0 = 100%, 0.1 = 10%
+
+  mattr_accessor :retention_period, default: 7.days
+  mattr_accessor :captured_events, default: []      # Empty = capture all
+  mattr_accessor :ignored_events, default: [
+    /^active_record\./,
+    /^action_controller\./,
+    /^action_view\./,
+    /^active_job\./,
+    /^action_mailer\./,
+    /^active_storage\./,
+    /^action_cable\./,
+    /^rails\./,
+    /^turbo\./,
+    /^cache_/,
+    /\.sql$/,
+    /^solid_/
+  ]
+  mattr_accessor :per_page, default: 25
+
+  mattr_accessor :http_basic_auth_enabled, default: false
+  mattr_accessor :http_basic_auth_user
+  mattr_accessor :http_basic_auth_password
+  mattr_accessor :authentication, default: nil
+
+  mattr_accessor :group_keys, default: [:request_id]
+
+  mattr_accessor :logger
+
+  class << self
+    def configure
+      yield self
+    end
+
+    ADAPTER_LOCK = Mutex.new
+
+    def adapter
+      @adapter || ADAPTER_LOCK.synchronize { @adapter ||= build_adapter }
+    end
+
+    def reset_adapter!
+      ADAPTER_LOCK.synchronize { @adapter = nil }
+    end
+
+    def events
+      EventsRelation.new(adapter: adapter)
+    end
+
+    def subscriber
+      @subscriber ||= Subscriber.new
+    end
+
+    def subscribe!
+      return unless defined?(Rails.event)
+
+      Rails.event.subscribe(subscriber)
+    end
+
+    def shutdown!
+      subscriber.stop!
+    end
+
+    private
+
+    def build_adapter
+      adapter_instance = case storage_adapter
+      when :active_record
+        require "rails_event_viewer/adapters/active_record"
+        Adapters::ActiveRecord.new(**adapter_options)
+      when :redis
+        require "rails_event_viewer/adapters/redis"
+        Adapters::Redis.new(**adapter_options)
+      when :memory
+        require "rails_event_viewer/adapters/memory"
+        Adapters::Memory.new(**adapter_options)
+      when :null
+        require "rails_event_viewer/adapters/null"
+        Adapters::Null.new
+      when Class
+        storage_adapter.new(**adapter_options)
+      else
+        raise ArgumentError, "Unknown adapter: #{storage_adapter}. " \
+          "Valid options: :active_record, :redis, :memory, :null, or a custom adapter class"
+      end
+
+      if storage_adapter == :active_record && !adapter_instance.table_exists?
+        effective_logger.warn "[RailsEventViewer] Table 'rails_event_viewer_entries' not found. " \
+                              "Run `rails rails_event_viewer:install:migrations` and `rails db:migrate`. " \
+                              "Falling back to NullAdapter (events will not be persisted)."
+        require "rails_event_viewer/adapters/null"
+        Adapters::Null.new
+      else
+        adapter_instance
+      end
+    end
+
+    def effective_logger
+      logger || (defined?(Rails) && Rails.logger) || Logger.new($stdout)
+    end
+  end
+end
+
+require "rails_event_viewer/adapter"
+require "rails_event_viewer/events_relation"
+require "rails_event_viewer/subscriber"
+require "rails_event_viewer/json_query"
+require "rails_event_viewer/pagy_countable"
+require "rails_event_viewer/time_utils"

data/lib/tasks/rails_event_viewer_tasks.rake

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+namespace :rails_event_viewer do
+  desc "Delete events older than the configured retention period"
+  task cleanup: :environment do
+    retention_period = RailsEventViewer.retention_period
+    cutoff_time = Time.current - retention_period
+
+    puts "RailsEventViewer: Cleaning up events older than #{cutoff_time}..."
+
+    deleted_count = RailsEventViewer.adapter.delete_before(cutoff_time)
+
+    puts "RailsEventViewer: Deleted #{deleted_count || 'unknown number of'} events."
+  end
+
+  desc "Show event statistics"
+  task stats: :environment do
+    adapter = RailsEventViewer.adapter
+    adapter_name = adapter.class.name.split("::").last
+
+    puts ""
+    puts "RailsEventViewer Statistics"
+    puts "=" * 40
+    puts "Storage Adapter: #{adapter_name}"
+    puts ""
+
+    total = RailsEventViewer.events.count
+    puts "Total Events: #{total}"
+
+    last_hour = adapter.count_since(1.hour.ago) rescue "N/A"
+    last_day = adapter.count_since(1.day.ago) rescue "N/A"
+    last_week = adapter.count_since(1.week.ago) rescue "N/A"
+
+    puts ""
+    puts "Events by Time Period:"
+    puts "  Last hour:  #{last_hour}"
+    puts "  Last day:   #{last_day}"
+    puts "  Last week:  #{last_week}"
+
+    puts ""
+    puts "Top 10 Event Types:"
+    top_events = adapter.counts_by_name(limit: 10) rescue {}
+    if top_events.empty?
+      puts "  (no events)"
+    else
+      top_events.each do |name, count|
+        puts "  #{name}: #{count}"
+      end
+    end
+
+    puts ""
+  end
+
+  desc "Clear all events (use with caution!)"
+  task clear: :environment do
+    adapter = RailsEventViewer.adapter
+
+    if adapter.respond_to?(:clear!)
+      print "Are you sure you want to delete ALL events? [y/N] "
+      response = $stdin.gets.chomp.downcase
+
+      if response == "y"
+        adapter.clear!
+        puts "All events have been cleared."
+      else
+        puts "Cancelled."
+      end
+    else
+      puts "Clear operation not supported by #{adapter.class.name}"
+    end
+  end
+
+  desc "Flush any buffered events to storage"
+  task flush: :environment do
+    puts "Flushing buffered events..."
+
+    RailsEventViewer.subscriber.flush!
+
+    puts "Done."
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: rails_event_viewer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Keshav Biswa
+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: 8.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.0
+- !ruby/object:Gem::Dependency
+  name: pagy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '43.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '43.0'
+- !ruby/object:Gem::Dependency
+  name: chartkick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: groupdate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: RailsEventViewer provides a web interface to browse, search, and analyze
+  structured events emitted via Rails.event. Features include event listing, filtering,
+  search, and analytics dashboards.
+email:
+- keshavbiswa21@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/rails_event_viewer/application.css
+- app/assets/stylesheets/rails_event_viewer/tailwind.css
+- app/controllers/rails_event_viewer/analytics_controller.rb
+- app/controllers/rails_event_viewer/application_controller.rb
+- app/controllers/rails_event_viewer/dashboard_controller.rb
+- app/controllers/rails_event_viewer/event_types_controller.rb
+- app/controllers/rails_event_viewer/events_controller.rb
+- app/controllers/rails_event_viewer/groups_controller.rb
+- app/helpers/rails_event_viewer/application_helper.rb
+- app/models/rails_event_viewer/application_record.rb
+- app/models/rails_event_viewer/entry.rb
+- app/views/layouts/rails_event_viewer/application.html.erb
+- app/views/rails_event_viewer/analytics/overview.html.erb
+- app/views/rails_event_viewer/dashboard/index.html.erb
+- app/views/rails_event_viewer/event_types/index.html.erb
+- app/views/rails_event_viewer/event_types/show.html.erb
+- app/views/rails_event_viewer/events/_event_row.html.erb
+- app/views/rails_event_viewer/events/_filters_sidebar.html.erb
+- app/views/rails_event_viewer/events/index.html.erb
+- app/views/rails_event_viewer/events/show.html.erb
+- app/views/rails_event_viewer/groups/index.html.erb
+- app/views/rails_event_viewer/groups/show.html.erb
+- app/views/rails_event_viewer/shared/_navigation.html.erb
+- app/views/rails_event_viewer/shared/_pagination.html.erb
+- app/views/rails_event_viewer/shared/_stat_card.html.erb
+- config/routes.rb
+- db/migrate/20241208000001_create_rails_event_viewer_entries.rb
+- lib/generators/rails_event_viewer/install/USAGE
+- lib/generators/rails_event_viewer/install/install_generator.rb
+- lib/generators/rails_event_viewer/install/templates/create_rails_event_viewer_entries.rb.erb
+- lib/generators/rails_event_viewer/install/templates/initializer.rb.erb
+- lib/rails_event_viewer.rb
+- lib/rails_event_viewer/adapter.rb
+- lib/rails_event_viewer/adapters/active_record.rb
+- lib/rails_event_viewer/adapters/concerns/in_memory_filtering.rb
+- lib/rails_event_viewer/adapters/memory.rb
+- lib/rails_event_viewer/adapters/null.rb
+- lib/rails_event_viewer/adapters/redis.rb
+- lib/rails_event_viewer/engine.rb
+- lib/rails_event_viewer/events_relation.rb
+- lib/rails_event_viewer/json_query.rb
+- lib/rails_event_viewer/pagy_countable.rb
+- lib/rails_event_viewer/subscriber.rb
+- lib/rails_event_viewer/time_utils.rb
+- lib/rails_event_viewer/version.rb
+- lib/tasks/rails_event_viewer_tasks.rake
+homepage: https://github.com/keshavbiswa/rails_event_viewer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/keshavbiswa/rails_event_viewer
+  source_code_uri: https://github.com/keshavbiswa/rails_event_viewer
+  changelog_uri: https://github.com/keshavbiswa/rails_event_viewer/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A Rails engine to view structured events from Rails Event Reporter
+test_files: []