rails_event_viewer 0.1.0

data/lib/generators/rails_event_viewer/install/templates/initializer.rb.erb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+RailsEventViewer.configure do |config|
+  # ==========================================================================
+  # Storage Configuration
+  # ==========================================================================
+
+  # Choose your storage adapter:
+  #   :active_record - Stores events in your database (default)
+  #   :redis         - Stores events in Redis (ephemeral, high-volume)
+  #   :memory        - In-memory storage (development/testing only)
+  #   :null          - Discards all events (useful for disabling in production)
+  #   CustomAdapter  - Pass a custom class that includes RailsEventViewer::Adapter
+  #
+  config.storage_adapter = :<%= storage_adapter %>
+<% if storage_adapter == "redis" %>
+
+  config.adapter_options = {
+    # redis: Redis.new(url: ENV["REDIS_URL"]),  # Your Redis instance
+    # key_prefix: "rails_event_viewer",          # Key prefix for Redis keys
+    # max_events: 10_000                         # Maximum events to retain
+  }
+<% elsif storage_adapter == "active_record" %>
+
+  # ActiveRecord adapter options (none required for default setup)
+  # config.adapter_options = {}
+<% end %>
+
+  # ==========================================================================
+  # Performance Configuration
+  # ==========================================================================
+
+  # Enable async buffered writes for better performance
+  # When true, events are buffered and flushed in batches
+  # config.async = true
+
+  # Number of events to buffer before auto-flushing
+  # config.buffer_size = 100
+
+  # Flush interval in seconds (flushes even if buffer isn't full)
+  # config.flush_interval = 2
+
+  # Sample rate: 1.0 = capture all events, 0.1 = capture 10% of events
+  # Useful for high-volume production environments
+  # config.sample_rate = 1.0
+
+  # ==========================================================================
+  # General Configuration
+  # ==========================================================================
+
+  # How long to keep events before cleanup (used by retention task)
+  # config.retention_period = 7.days
+
+  # Only capture specific events (empty = capture all Rails.event.notify() events)
+  # Note: This only affects events emitted via Rails.event.notify(), NOT internal
+  # Rails instrumentation events (sql.active_record, process_action.action_controller, etc.)
+  # which use ActiveSupport::Notifications and are not captured by this gem.
+  # config.captured_events = ["user.created", "order.placed"]
+
+  # Ignore specific events (supports strings and regex patterns)
+  # config.ignored_events = ["internal.heartbeat", /^debug\./]
+
+  # Default pagination limit
+  # config.per_page = 25
+
+  # ==========================================================================
+  # Group Tracking
+  # ==========================================================================
+
+  # Context/tag keys used to group related events together
+  # Events sharing the same value for these keys are shown together
+  # Example: All events with the same request_id form a "request group"
+  # config.group_keys = [:request_id, :order_id, :job_id, :user_id]
+
+  # ==========================================================================
+  # Authentication
+  # ==========================================================================
+
+  # Option 1: HTTP Basic Auth (simple, good for internal tools)
+  # config.http_basic_auth_enabled = true
+  # config.http_basic_auth_user = ENV["RAILS_EVENT_VIEWER_USER"]
+  # config.http_basic_auth_password = ENV["RAILS_EVENT_VIEWER_PASSWORD"]
+
+  # Option 2: Custom authentication (flexible, integrates with your auth system)
+  # The block receives the controller instance
+  # config.authentication = ->(controller) {
+  #   controller.authenticate_user!  # Devise example
+  #   controller.current_user.admin? # Require admin role
+  # }
+end

data/lib/rails_event_viewer/adapter.rb

@@ -0,0 +1,93 @@
+module RailsEventViewer
+  module Adapter
+    extend ActiveSupport::Concern
+
+    def supports_persistence?
+      true
+    end
+
+    def supports_analytics?
+      true
+    end
+
+    def supports_retention?
+      true
+    end
+
+    def write_events(events)
+      raise NotImplementedError, "#{self.class} must implement #write_events"
+    end
+
+    def fetch_events(relation)
+      raise NotImplementedError, "#{self.class} must implement #fetch_events"
+    end
+
+    def count_events(relation)
+      raise NotImplementedError, "#{self.class} must implement #count_events"
+    end
+
+    def distinct_event_names
+      raise NotImplementedError, "#{self.class} must implement #distinct_event_names"
+    end
+
+    def delete_before(timestamp)
+      raise NotImplementedError, "#{self.class} must implement #delete_before"
+    end
+
+    def find_event(id)
+      raise NotImplementedError, "#{self.class} must implement #find_event"
+    end
+
+    def events_over_time(since:, interval:)
+      raise NotImplementedError, "#{self.class} must implement #events_over_time" if supports_analytics?
+      {}
+    end
+
+    def counts_by_name(limit:)
+      raise NotImplementedError, "#{self.class} must implement #counts_by_name" if supports_analytics?
+      {}
+    end
+
+    def count_since(since)
+      raise NotImplementedError, "#{self.class} must implement #count_since" if supports_analytics?
+      0
+    end
+
+    def event_type_statistics
+      distinct_event_names.map do |name|
+        build_event_type_stats(name)
+      end.sort_by { |s| -s[:count] }
+    end
+
+    def distinct_group_values(key, source: :context)
+      raise NotImplementedError, "#{self.class} must implement #distinct_group_values"
+    end
+
+    def group_instances(key, source: :context, limit: 100)
+      raise NotImplementedError, "#{self.class} must implement #group_instances"
+    end
+
+    def event_time_span(relation)
+      [nil, nil]
+    end
+
+    private
+
+    def build_event_type_stats(name)
+      relation = RailsEventViewer.events.with_name(name)
+      last_event = relation.first
+
+      {
+        name: name,
+        count: relation.count,
+        last_event_at: extract_occurred_at(last_event)
+      }
+    end
+
+    def extract_occurred_at(event)
+      return nil unless event
+
+      event.respond_to?(:occurred_at) ? event.occurred_at : event[:occurred_at]
+    end
+  end
+end

data/lib/rails_event_viewer/adapters/active_record.rb

@@ -0,0 +1,227 @@
+module RailsEventViewer
+  module Adapters
+    class ActiveRecord
+      include Adapter
+
+      def initialize(**options)
+        @options = options
+      end
+
+      def table_exists?
+        Entry.table_exists?
+      rescue ::ActiveRecord::NoDatabaseError, ::ActiveRecord::StatementInvalid
+        false
+      end
+
+      def write_events(events)
+        return if events.empty?
+
+        # Use insert_all for bulk inserts (more efficient)
+        records = events.map do |event|
+          {
+            name: event[:name],
+            payload: event[:payload] || {},
+            tags: event[:tags] || {},
+            context: event[:context] || {},
+            source_file: event[:source_file],
+            source_line: event[:source_line],
+            source_label: event[:source_label],
+            occurred_at: event[:occurred_at],
+            created_at: Time.current,
+            updated_at: Time.current
+          }
+        end
+
+        Entry.insert_all(records)
+      end
+
+      def fetch_events(relation)
+        build_scope(relation)
+          .offset(relation.offset_value)
+          .limit(relation.limit_value)
+      end
+
+      def count_events(relation)
+        build_scope(relation).count
+      end
+
+      def distinct_event_names
+        Entry.distinct.pluck(:name).compact.sort
+      end
+
+      def find_event(id)
+        Entry.find_by(id: id)
+      end
+
+      def delete_before(timestamp)
+        Entry.where("occurred_at < ?", timestamp).in_batches.delete_all
+      end
+
+      def events_over_time(since:, interval:)
+        scope = Entry.where("occurred_at >= ?", since)
+
+        case interval
+        when :minute
+          scope.group_by_minute(:occurred_at).count
+        when :hour
+          scope.group_by_hour(:occurred_at).count
+        when :day
+          scope.group_by_day(:occurred_at).count
+        when :week
+          scope.group_by_week(:occurred_at).count
+        else
+          scope.group_by_hour(:occurred_at).count
+        end
+      end
+
+      def counts_by_name(limit:)
+        Entry.group(:name)
+             .order(Arel.sql("COUNT(*) DESC"))
+             .limit(limit)
+             .count
+      end
+
+      def count_since(since)
+        Entry.where("occurred_at >= ?", since).count
+      end
+
+      def event_type_statistics
+        Entry
+          .group(:name)
+          .order(Arel.sql("COUNT(*) DESC"))
+          .pluck(:name, Arel.sql("COUNT(*)"), Arel.sql("MAX(occurred_at)"))
+          .map do |name, count, last_event_at|
+            {
+              name: name,
+              count: count,
+              last_event_at: parse_timestamp(last_event_at)
+            }
+          end
+      end
+
+      def distinct_group_values(key, source: :context)
+        column = source == :tags ? :tags : :context
+        json_path = JsonQuery.extract_path(column, key)
+
+        Entry
+          .where(JsonQuery.extract_path_not_null(column, key))
+          .distinct
+          .pluck(Arel.sql(json_path))
+          .compact
+          .map { |v| v.is_a?(String) ? v.gsub(/^"|"$/, "") : v.to_s }
+          .uniq
+      end
+
+      def group_instances(key, source: :context, limit: 100)
+        column = source == :tags ? :tags : :context
+        json_path = JsonQuery.extract_path(column, key)
+
+        Entry
+          .select(
+            Arel.sql("#{json_path} as group_value"),
+            Arel.sql("COUNT(*) as event_count"),
+            Arel.sql("MIN(occurred_at) as first_event_at"),
+            Arel.sql("MAX(occurred_at) as last_event_at")
+          )
+          .where(JsonQuery.extract_path_not_null(column, key))
+          .group(Arel.sql(json_path))
+          .order(Arel.sql("MAX(occurred_at) DESC"))
+          .limit(limit)
+          .map do |row|
+            {
+              value: normalize_group_value(row.group_value),
+              count: row.event_count,
+              first_event_at: parse_timestamp(row.first_event_at),
+              last_event_at: parse_timestamp(row.last_event_at)
+            }
+          end
+      end
+
+      def fetch_last(relation)
+        build_scope(relation).reorder(occurred_at: :asc, id: :asc).first
+      end
+
+      def event_time_span(relation)
+        row = build_scope(relation).pick(
+          Arel.sql("MIN(occurred_at)"),
+          Arel.sql("MAX(occurred_at)")
+        )
+        return [nil, nil] unless row
+        [parse_timestamp(row[0]), parse_timestamp(row[1])]
+      end
+
+      private
+
+      def parse_timestamp(value)
+        return nil if value.nil?
+        return value if value.is_a?(Time)
+
+        ActiveSupport::TimeZone["UTC"].parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def normalize_group_value(value)
+        return nil if value.nil?
+        return value.to_s if value.is_a?(Numeric)
+
+        value.to_s.gsub(/^"|"$/, "")
+      end
+
+      def build_scope(relation)
+        scope = Entry.order(occurred_at: :desc)
+        scope = apply_name_filters(scope, relation)
+        scope = apply_tag_filters(scope, relation)
+        scope = apply_context_filters(scope, relation)
+        scope = apply_time_filters(scope, relation)
+        scope = apply_search(scope, relation)
+        scope
+      end
+
+      def apply_name_filters(scope, relation)
+        return scope if relation.names.blank?
+
+        if relation.names.size == 1
+          scope.where(name: relation.names.first)
+        else
+          scope.where(name: relation.names)
+        end
+      end
+
+      def apply_tag_filters(scope, relation)
+        return scope if relation.tags.blank?
+
+        relation.tags.each do |key, value|
+          scope = scope.where(*JsonQuery.contains(:tags, key, value))
+        end
+        scope
+      end
+
+      def apply_context_filters(scope, relation)
+        return scope if relation.contexts.blank?
+
+        relation.contexts.each do |key, value|
+          scope = scope.where(*JsonQuery.contains(:context, key, value))
+        end
+        scope
+      end
+
+      def apply_time_filters(scope, relation)
+        scope = scope.where("occurred_at >= ?", relation.since_time) if relation.since_time
+        scope = scope.where("occurred_at <= ?", relation.until_time) if relation.until_time
+        scope
+      end
+
+      def apply_search(scope, relation)
+        return scope if relation.query.blank?
+
+        sanitized = "%#{Entry.sanitize_sql_like(relation.query.downcase)}%"
+        text_type = JsonQuery.detect_adapter == :mysql ? "CHAR" : "TEXT"
+        scope.where(
+          "LOWER(name) LIKE :q ESCAPE '\\' OR LOWER(CAST(payload AS #{text_type})) LIKE :q ESCAPE '\\'",
+          q: sanitized
+        )
+      end
+    end
+  end
+end

data/lib/rails_event_viewer/adapters/concerns/in_memory_filtering.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RailsEventViewer
+  module Adapters
+    module Concerns
+      module InMemoryFiltering
+        extend ActiveSupport::Concern
+
+        def distinct_group_values(key, source: :context)
+          in_memory_events
+            .map { |e| group_value_for(e, key, source) }
+            .compact
+            .uniq
+        end
+
+        def group_instances(key, source: :context, limit: 100)
+          in_memory_events
+            .group_by { |e| group_value_for(e, key, source) }
+            .reject { |value, _| value.nil? }
+            .map { |value, events| build_group_instance(value, events) }
+            .sort_by { |s| -(s[:last_event_at]&.to_f || 0) }
+            .take(limit)
+        end
+
+        def event_time_span(relation)
+          filtered = filter_events(in_memory_events, relation)
+          timestamps = filtered.filter_map { |e| e[:occurred_at] }
+          [timestamps.min, timestamps.max]
+        end
+
+        private
+
+        def group_value_for(event, key, source)
+          data = event[source]
+          data&.dig(key.to_s) || data&.dig(key.to_sym)
+        end
+
+        def build_group_instance(value, events)
+          timestamps = events.map { |e| e[:occurred_at] }.compact
+          {
+            value: value,
+            count: events.size,
+            first_event_at: timestamps.min,
+            last_event_at: timestamps.max
+          }
+        end
+
+        def filter_events(events, relation)
+          result = events
+
+          result = filter_by_names(result, relation.names)
+          result = filter_by_tags(result, relation.tags)
+          result = filter_by_contexts(result, relation.contexts)
+          result = filter_by_time_range(result, relation.since_time, relation.until_time)
+          result = filter_by_search_query(result, relation.query)
+
+          result
+        end
+
+        def filter_by_names(events, names)
+          return events if names.blank?
+
+          events.select { |e| names.include?(e[:name]) }
+        end
+
+        def filter_by_tags(events, tags)
+          return events if tags.blank?
+
+          events.select do |e|
+            event_tags = e[:tags] || {}
+            tags.all? do |key, value|
+              hash_key_matches?(event_tags, key, value)
+            end
+          end
+        end
+
+        def filter_by_contexts(events, contexts)
+          return events if contexts.blank?
+
+          events.select do |e|
+            event_context = e[:context] || {}
+            contexts.all? do |key, value|
+              hash_key_matches?(event_context, key, value)
+            end
+          end
+        end
+
+        def hash_key_matches?(hash, key, value)
+          if value.nil?
+            hash.key?(key.to_s) || hash.key?(key.to_sym)
+          else
+            values_match?(hash[key.to_s], value) || values_match?(hash[key.to_sym], value)
+          end
+        end
+
+        def values_match?(actual, expected)
+          return false if actual.nil?
+
+          actual == expected || actual.to_s == expected.to_s
+        end
+
+        def filter_by_time_range(events, since_time, until_time)
+          result = events
+
+          if since_time
+            result = result.select { |e| e[:occurred_at] && e[:occurred_at] >= since_time }
+          end
+
+          if until_time
+            result = result.select { |e| e[:occurred_at] && e[:occurred_at] <= until_time }
+          end
+
+          result
+        end
+
+        def filter_by_search_query(events, query)
+          return events if query.blank?
+
+          query_downcase = query.downcase
+          events.select do |e|
+            name_matches?(e[:name], query_downcase) ||
+              payload_matches?(e[:payload], query_downcase)
+          end
+        end
+
+        def name_matches?(name, query)
+          name&.downcase&.include?(query)
+        end
+
+        def payload_matches?(payload, query)
+          payload.to_s.downcase.include?(query)
+        end
+      end
+    end
+  end
+end

data/lib/rails_event_viewer/adapters/memory.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "concerns/in_memory_filtering"
+
+module RailsEventViewer
+  module Adapters
+    class Memory
+      include Adapter
+      include Concerns::InMemoryFiltering
+
+      @events = []
+      @id_counter = 0
+      @mutex = Mutex.new
+
+      class << self
+        attr_accessor :events, :id_counter, :mutex
+      end
+
+      def events
+        self.class.events
+      end
+
+      def initialize(max_events: 1000, **)
+        @max_events = max_events
+      end
+
+      def supports_retention?
+        true
+      end
+
+      def write_events(new_events)
+        return if new_events.empty?
+
+        mutex.synchronize do
+          new_events.each do |event|
+            self.class.id_counter += 1
+            events << event.merge(id: self.class.id_counter)
+          end
+          trim_to_max
+        end
+      end
+
+      def fetch_events(relation)
+        sorted = sort_by_occurred_at(mutex.synchronize { events.dup })
+        filtered = filter_events(sorted, relation)
+        filtered.drop(relation.offset_value).take(relation.limit_value)
+      end
+
+      def count_events(relation)
+        filter_events(mutex.synchronize { events.dup }, relation).size
+      end
+
+      def distinct_event_names
+        mutex.synchronize { events.map { |e| e[:name] } }.uniq.compact.sort
+      end
+
+      def find_event(id)
+        parsed = Integer(id, exception: false)
+        return nil unless parsed
+        mutex.synchronize { events.find { |e| e[:id] == parsed } }
+      end
+
+      def delete_before(timestamp)
+        mutex.synchronize do
+          original_size = events.size
+          events.reject! { |e| e[:occurred_at] && e[:occurred_at] < timestamp }
+          original_size - events.size
+        end
+      end
+
+      def events_over_time(since:, interval:)
+        snapshot = mutex.synchronize { events.dup }
+        filtered = snapshot.select { |e| e[:occurred_at] && e[:occurred_at] >= since }
+
+        grouped = filtered.group_by do |e|
+          TimeUtils.truncate_to_interval(e[:occurred_at], interval)
+        end
+
+        grouped.transform_values(&:size).sort.to_h
+      end
+
+      def counts_by_name(limit:)
+        mutex.synchronize { events.dup }
+          .group_by { |e| e[:name] }
+          .transform_values(&:size)
+          .sort_by { |_, count| -count }
+          .take(limit)
+          .to_h
+      end
+
+      def count_since(since)
+        mutex.synchronize { events.count { |e| e[:occurred_at] && e[:occurred_at] >= since } }
+      end
+
+      def clear!
+        mutex.synchronize do
+          events.clear
+          self.class.id_counter = 0
+        end
+      end
+
+      def size
+        mutex.synchronize { events.size }
+      end
+
+      private
+
+      def in_memory_events
+        mutex.synchronize { events.dup }
+      end
+
+      def mutex
+        self.class.mutex
+      end
+
+      def sort_by_occurred_at(evts)
+        evts.sort_by { |e| -(e[:occurred_at]&.to_f || 0) }
+      end
+
+      def trim_to_max
+        return unless events.size > @max_events
+
+        events.sort_by! { |e| e[:occurred_at]&.to_f || 0 }
+        events.slice!(0, events.size - @max_events)
+      end
+    end
+  end
+end