railswatch 1.0.0

data/app/views/railswatch/shared/_page_header.html.erb

@@ -0,0 +1,23 @@
+<header class="rm-page-header">
+  <div class="rm-page-header__copy">
+    <p class="rm-page-header__eyebrow"><%= eyebrow %></p>
+    <div class="rm-page-header__title-row">
+      <h1 class="rm-page-header__title"><%= title %></h1>
+      <% if local_assigns[:badge].present? %>
+        <span class="rm-badge"><%= badge %></span>
+      <% end %>
+    </div>
+    <p class="rm-page-header__description"><%= description %></p>
+  </div>
+
+  <div class="rm-page-header__actions">
+    <% if local_assigns[:autoupdate_interval].present? %>
+      <railswatch-autoupdate interval="<%= autoupdate_interval %>">
+        <label class="rm-toggle" id="autoupdate_label">
+          <input type="checkbox" />
+          <span>Auto-update</span>
+        </label>
+      </railswatch-autoupdate>
+    <% end %>
+  </div>
+</header>

data/config/routes.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Railswatch::Engine.routes.draw do
+  get '/' => 'railswatch#index', :as => :railswatch
+
+  get '/requests' => 'railswatch#requests', :as => :railswatch_requests
+  get '/crashes' => 'railswatch#crashes', :as => :railswatch_crashes
+  get '/recent' => 'railswatch#recent', :as => :railswatch_recent
+  get '/slow' => 'railswatch#slow', :as => :railswatch_slow
+
+  get '/trace/:id' => 'railswatch#trace', :as => :railswatch_trace
+  get '/summary' => 'railswatch#summary', :as => :railswatch_summary
+
+  get '/sidekiq' => 'railswatch#sidekiq', :as => :railswatch_sidekiq
+  get '/delayed_job' => 'railswatch#delayed_job', :as => :railswatch_delayed_job
+  get '/grape' => 'railswatch#grape', :as => :railswatch_grape
+  get '/rake' => 'railswatch#rake', :as => :railswatch_rake
+  get '/custom' => 'railswatch#custom', :as => :railswatch_custom
+  get '/resources' => 'railswatch#resources', :as => :railswatch_resources
+end
+
+Rails.application.routes.draw do
+  mount Railswatch::Engine => Railswatch.mount_at, :as => 'railswatch'
+rescue ArgumentError
+  # already added
+  # this code exist here because engine not includes routing automatically
+end

data/lib/generators/railswatch/install/USAGE

@@ -0,0 +1,19 @@
+Description:
+    Generates initial config and database migration for railswatch
+
+Example:
+    bin/rails generate railswatch:install
+
+    This will create:
+        config/initializers/railswatch.rb
+        db/migrate/TIMESTAMP_create_railswatch_tables.rb
+
+    Primary database setup:
+        keep `config.database_connection_name = nil`
+        bin/rails db:migrate
+
+    Separate database setup:
+        add `railswatch` to config/database.yml
+        set `config.database_connection_name = :railswatch`
+        bin/rails db:migrate
+        bin/rails db:migrate:railswatch

data/lib/generators/railswatch/install/install_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rails/generators/migration'
+
+module Railswatch
+  class InstallGenerator < ::Rails::Generators::Base
+    include ::Rails::Generators::Migration
+
+    source_root File.expand_path('templates', __dir__)
+    desc 'Generates initial config for railswatch gem'
+
+    def copy_initializer_file
+      copy_file 'initializer.rb', 'config/initializers/railswatch.rb'
+    end
+
+    def install_migration
+      migration_template(
+        'create_railswatch_tables.rb',
+        'db/migrate/create_railswatch_tables.rb'
+      )
+    end
+
+    def show_database_setup # rubocop:disable Metrics/MethodLength
+      say <<~TEXT
+
+        railswatch was configured with database-backed storage.
+
+        Primary database:
+          Leave `config.database_connection_name = nil`.
+          Run `bin/rails db:migrate`.
+
+        Separate database:
+          1. Add a `railswatch` database entry to `config/database.yml`
+          2. Set `config.database_connection_name = :railswatch`
+          3. Run `bin/rails db:migrate` for your app database
+          4. Run `bin/rails db:migrate:railswatch`
+
+        You can prune old data later with `bin/rails railswatch:prune`.
+      TEXT
+    end
+
+    def self.next_migration_number(_dirname)
+      Time.now.utc.strftime('%Y%m%d%H%M%S')
+    end
+  end
+end

data/lib/generators/railswatch/install/templates/create_railswatch_tables.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+class CreateRailswatchTables < ActiveRecord::Migration[7.0]
+  def change # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    create_table :railswatch_request_records do |t|
+      t.string :controller
+      t.string :action
+      t.string :format
+      t.string :status
+      t.string :http_method
+      t.string :path
+      t.string :request_id, null: false
+      t.float :duration_ms
+      t.float :view_runtime_ms
+      t.float :db_runtime_ms
+      t.string :http_referer
+      t.text :custom_data
+      t.text :exception
+      t.text :backtrace
+      t.text :request_context
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_request_records, :occurred_at
+    add_index :railswatch_request_records, :request_id, unique: true
+    add_index :railswatch_request_records, %i[status occurred_at],
+              name: 'idx_rp_requests_on_status_and_occurred_at'
+    add_index :railswatch_request_records, %i[controller action format occurred_at],
+              name: 'idx_rp_requests_on_grouping_fields'
+
+    create_table :railswatch_trace_records do |t|
+      t.string :request_id, null: false
+      t.text :entries
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_trace_records, :request_id, unique: true
+    add_index :railswatch_trace_records, :occurred_at
+
+    create_table :railswatch_sidekiq_records do |t|
+      t.string :queue
+      t.string :worker
+      t.string :jid, null: false
+      t.integer :enqueued_ati
+      t.integer :start_timei
+      t.string :status
+      t.float :duration_ms
+      t.text :message
+      t.text :job_args
+      t.text :error_backtrace
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_sidekiq_records, :occurred_at
+    add_index :railswatch_sidekiq_records, %i[queue worker occurred_at],
+              name: 'idx_rp_sidekiq_on_queue_worker_time'
+    add_index :railswatch_sidekiq_records, :jid
+
+    create_table :railswatch_delayed_job_records do |t|
+      t.string :jid
+      t.string :source_type
+      t.string :class_name
+      t.string :method_name
+      t.string :status
+      t.float :duration_ms
+      t.text :job_args
+      t.text :error_message
+      t.text :error_backtrace
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_delayed_job_records, :occurred_at
+    add_index :railswatch_delayed_job_records, %i[status occurred_at], name: 'idx_rp_delayed_jobs_on_status_time'
+
+    create_table :railswatch_grape_records do |t|
+      t.string :format
+      t.string :path
+      t.string :status
+      t.string :http_method
+      t.string :request_id
+      t.float :endpoint_render_grape_ms
+      t.float :endpoint_run_grape_ms
+      t.float :format_response_grape_ms
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_grape_records, :occurred_at
+    add_index :railswatch_grape_records, %i[status occurred_at], name: 'idx_rp_grape_on_status_time'
+
+    create_table :railswatch_rake_records do |t|
+      t.text :task
+      t.string :status
+      t.float :duration_ms
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_rake_records, :occurred_at
+    add_index :railswatch_rake_records, %i[status occurred_at], name: 'idx_rp_rake_on_status_time'
+
+    create_table :railswatch_custom_records do |t|
+      t.string :tag_name
+      t.string :namespace_name
+      t.string :status
+      t.float :duration_ms
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_custom_records, :occurred_at
+    add_index :railswatch_custom_records, %i[status occurred_at], name: 'idx_rp_custom_on_status_time'
+
+    create_table :railswatch_resource_records do |t|
+      t.string :server
+      t.string :context
+      t.string :role
+      t.text :payload
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_resource_records, :occurred_at
+    add_index :railswatch_resource_records, %i[server context role occurred_at],
+              name: 'idx_rp_resources_on_server_context_role_time'
+
+    create_table :railswatch_event_records do |t|
+      t.string :name
+      t.text :options
+      t.datetime :occurred_at, null: false
+      t.timestamps
+    end
+
+    add_index :railswatch_event_records, :occurred_at
+  end
+end

data/lib/generators/railswatch/install/templates/initializer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+if defined?(Railswatch)
+  Railswatch.setup do |config|
+    # Use the primary application database by default.
+    # To use a dedicated database, define an additional database config and set:
+    # config.database_connection_name = :railswatch
+    config.database_connection_name = nil
+
+    # All data we collect
+    config.duration = 4.hours
+
+    # Recent Requests configuration
+    config.recent_requests_time_window = 60.minutes
+    # config.recent_requests_limit = nil # number of recent requests
+
+    # Slow Requests configuration
+    config.slow_requests_time_window = 4.hours
+    # config.slow_requests_limit = 500 # number of slow requests
+    config.slow_requests_threshold = 500 # ms
+
+    config.retention = {
+      requests: config.duration,
+      sidekiq: config.duration,
+      delayed_job: config.duration,
+      grape: config.duration,
+      rake: config.duration,
+      custom: config.duration,
+      traces: config.recent_requests_time_window,
+      resources: 24.hours,
+      events: nil
+    }
+
+    config.debug = false
+    config.enabled = true
+
+    # default path where to mount gem
+    config.mount_at = '/railswatch'
+
+    # protect your Performance Dashboard with HTTP BASIC password
+    config.http_basic_authentication_enabled = false
+    config.http_basic_authentication_user_name = 'railswatch'
+    config.http_basic_authentication_password = 'password12'
+
+    # if you need an additional rules to check user permissions
+    config.verify_access_proc = proc { |_controller| true }
+    # for example when you have `current_user`
+    # config.verify_access_proc = proc { |controller| controller.current_user && controller.current_user.admin? }
+
+    # Override engine url options, necessary if hosting under a unique domain
+    # config.url_options = {host: "sub.example.com"}
+
+    # You can ignore endpoints with Rails standard notation controller#action
+    # config.ignored_endpoints = ['HomeController#contact']
+
+    # You can ignore request paths by specifying the beginning of the path.
+    # For example, all routes starting with '/admin' can be ignored:
+    config.ignored_paths = ['/railswatch']
+
+    # store custom data for the request
+    # config.custom_data_proc = proc do |env|
+    #   request = Rack::Request.new(env)
+    #   {
+    #     email: request.env['warden'].user&.email, # if you are using Devise for example
+    #     user_agent: request.env['HTTP_USER_AGENT']
+    #   }
+    # end
+
+    # Attach current user info to each request context (stored filtered alongside IP/params).
+    # The proc receives the raw Rack env and should return a plain hash.
+    # Sensitive values are filtered automatically — keep this lightweight (IDs, roles, emails).
+    # config.current_user_proc = proc do |env|
+    #   user = env['warden']&.user   # Devise / Warden
+    #   { id: user&.id, email: user&.email } if user
+    # end
+
+    # config home button link
+    config.home_link = '/'
+    config.skipable_rake_tasks = ['webpacker:compile']
+    config.include_rake_tasks = false
+    config.include_custom_events = true
+
+    # If enabled, the system monitor will be displayed on the dashboard
+    # to enabled add required gems (see README)
+    # config.system_monitor_duration = 24.hours
+  end
+end

data/lib/railswatch/data_source.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Railswatch
+  class DataSource
+    class RelationWrapper
+      extend Forwardable
+
+      def_delegators :@relation,
+                     :where, :order, :limit, :pluck, :map, :group, :count,
+                     :average, :maximum, :all, :to_a, :find_by, :each,
+                     :klass
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def data
+        @relation.to_a
+      end
+    end
+
+    KLASSES = {
+      requests: Railswatch::Models::RequestRecord,
+      sidekiq: Railswatch::Models::SidekiqRecord,
+      delayed_job: Railswatch::Models::DelayedJobRecord,
+      grape: Railswatch::Models::GrapeRecord,
+      rake: Railswatch::Models::RakeRecord,
+      custom: Railswatch::Models::CustomRecord,
+      resources: Railswatch::Models::ResourceRecord
+    }.freeze
+
+    attr_reader :query, :klass, :type, :days
+
+    def initialize(type:, query: {}, days: Railswatch::Utils.days(Railswatch.duration))
+      @type = type
+      @klass = KLASSES.fetch(type)
+      @query = query
+      @days = days
+    end
+
+    def db
+      scope = klass.all
+      scope = apply_time_window(scope)
+      RelationWrapper.new(apply_filters(scope))
+    end
+
+    def default?
+      query.empty?
+    end
+
+    private
+
+    def apply_time_window(scope)
+      return scope.where(occurred_at: query[:on].all_day) if query[:on].present?
+
+      now = Railswatch::Utils.kind_of_now
+      scope.where(occurred_at: (now - days.days)..now)
+    end
+
+    def apply_filters(scope) # rubocop:disable Metrics/MethodLength
+      case type
+      when :requests
+        apply_request_filters(scope)
+      when :resources
+        apply_resource_filters(scope)
+      when :sidekiq
+        apply_sidekiq_filters(scope)
+      when :delayed_job, :grape, :rake, :custom
+        apply_status_filter(scope)
+      else
+        scope
+      end
+    end
+
+    def apply_request_filters(scope) # rubocop:disable Metrics/AbcSize
+      scope = scope.where(controller: query[:controller]) if query[:controller].present?
+      scope = scope.where(action: query[:action]) if query[:action].present?
+      scope = scope.where(format: query[:format]) if query[:format].present?
+      scope = scope.where(status: query[:status].to_s) if query[:status].present?
+      scope = scope.where(http_method: query[:method]) if query[:method].present?
+      scope = scope.where(path: query[:path]) if query[:path].present?
+      scope
+    end
+
+    def apply_resource_filters(scope) # rubocop:disable Metrics/AbcSize
+      scope = scope.where(server: query[:server]) if query[:server].present?
+      scope = scope.where(context: query[:context]) if query[:context].present?
+      scope = scope.where(role: query[:role]) if query[:role].present?
+      scope
+    end
+
+    def apply_sidekiq_filters(scope) # rubocop:disable Metrics/AbcSize
+      scope = scope.where(queue: query[:queue]) if query[:queue].present?
+      scope = scope.where(worker: query[:worker]) if query[:worker].present?
+      scope = scope.where(status: query[:status].to_s) if query[:status].present?
+      scope
+    end
+
+    def apply_status_filter(scope)
+      scope = scope.where(status: query[:status].to_s) if query[:status].present?
+      scope
+    end
+  end
+end

data/lib/railswatch/engine.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'action_view/log_subscriber'
+require_relative 'rails/middleware'
+require_relative 'models/collection'
+require_relative 'instrument/metrics_collector'
+require_relative 'system_monitor/resources_monitor'
+
+module Railswatch
+  class Engine < ::Rails::Engine
+    isolate_namespace Railswatch
+
+    isolate_assets assets_subdir: 'engine_assets'
+
+    initializer 'railswatch.resource_monitor' do
+      # check required gems are available
+      Railswatch._resource_monitor_enabled =
+        !(defined?(Sys::Filesystem) && defined?(Sys::CPU) && defined?(GetProcessMem)).nil?
+
+      next unless Railswatch.enabled
+      next if ::Rails.env.test?
+      next if $railswatch_running_mode == :console # rubocop:disable Style/GlobalVars
+
+      # start monitoring
+      Railswatch._resource_monitor = Railswatch::SystemMonitor::ResourcesMonitor.new(
+        ENV['RAILSWATCH_SERVER_CONTEXT'].presence || 'rails',
+        ENV['RAILSWATCH_SERVER_ROLE'].presence || 'web'
+      )
+    end
+
+    initializer 'railswatch.middleware' do |app|
+      next unless Railswatch.enabled
+
+      app.middleware.insert_after ActionDispatch::Executor, Railswatch::Rails::Middleware
+      # look like it works in reverse order?
+      app.middleware.insert_before(
+        Railswatch::Rails::Middleware,
+        Railswatch::Rails::MiddlewareTraceStorerAndCleanup
+      )
+
+      if defined?(::Sidekiq)
+        require_relative 'gems/sidekiq_ext'
+
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Railswatch::Gems::SidekiqExt
+          end
+
+          config.on(:startup) do
+            if $railswatch_running_mode != :console # rubocop:disable Style/GlobalVars
+              # stop web monitoring
+              # when we run sidekiq it also starts web monitoring (see above)
+              Railswatch._resource_monitor.stop_monitoring
+              Railswatch._resource_monitor = nil
+              # start background monitoring
+              Railswatch._resource_monitor = Railswatch::SystemMonitor::ResourcesMonitor.new(
+                ENV['RAILSWATCH_SERVER_CONTEXT'].presence || 'sidekiq',
+                ENV['RAILSWATCH_SERVER_ROLE'].presence || 'background'
+              )
+            end
+          end
+        end
+      end
+
+      if defined?(::Grape)
+        require_relative 'gems/grape_ext'
+        Railswatch::Gems::GrapeExt.init
+      end
+
+      if defined?(::Delayed::Job)
+        require_relative 'gems/delayed_job_ext'
+        Railswatch::Gems::DelayedJobExt.init
+      end
+    end
+
+    initializer :configure_metrics, after: :initialize_logger do
+      next unless Railswatch.enabled
+
+      ActiveSupport::Notifications.subscribe(
+        'process_action.action_controller',
+        Railswatch::Instrument::MetricsCollector.new
+      )
+    end
+
+    config.after_initialize do
+      next unless Railswatch.enabled
+
+      Railswatch::Models::ApplicationRecord.reset_storage_connection!
+
+      ActionView::LogSubscriber.prepend Railswatch::Extensions::View
+      ActiveRecord::LogSubscriber.prepend Railswatch::Extensions::Db if defined?(ActiveRecord)
+
+      if defined?(::Rake::Task) && Railswatch.include_rake_tasks
+        require_relative 'gems/rake_ext'
+        Railswatch::Gems::RakeExt.init
+      end
+    end
+
+    if defined?(::Rails::Console)
+      $railswatch_running_mode = :console # rubocop:disable Style/GlobalVars
+    end
+  end
+end

data/lib/railswatch/events/record.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Events
+    class Record
+      attr_reader :record
+
+      DEFAULT_COLOR = '#FF00FF'
+      DEFAULT_LABEL_COLOR = '#FF00FF'
+      DEFAULT_LABEL_ORIENTATION = 'horizontal'
+
+      class << self
+        def create(name:, datetimei: Time.now.to_i, options: {})
+          model = Railswatch::Models::EventRecord.create!(
+            name: name,
+            options: options,
+            occurred_at: Railswatch::Utils.from_datetimei(datetimei.to_i)
+          )
+          new(model)
+        end
+
+        def all
+          Railswatch::Models::EventRecord.order(:occurred_at).map { |record| new(record) }
+        end
+      end
+
+      def initialize(record)
+        @record = record
+      end
+
+      delegate :name, to: :record
+
+      def datetimei
+        record.occurred_at.to_i
+      end
+
+      def options
+        (record.options || {}).deep_stringify_keys
+      end
+
+      def value
+        {
+          name: name,
+          datetime: record.occurred_at,
+          datetimei: datetimei,
+          options: options
+        }
+      end
+
+      def to_annotation
+        {
+          x: datetimei * 1000,
+          borderColor: options['borderColor'] || DEFAULT_COLOR,
+          label: {
+            borderColor: options.dig('label', 'borderColor') || DEFAULT_LABEL_COLOR,
+            orientation: options.dig('label', 'orientation') || DEFAULT_LABEL_ORIENTATION,
+            text: options.dig('label', 'text') || name
+          }
+        }
+      end
+    end
+  end
+end

data/lib/railswatch/extensions/trace.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Extensions
+    module View
+      # in env
+      # this works if config.log_level = :info
+      def info
+        CurrentRequest.current.trace({ group: :view, message: yield })
+        super
+      end
+    end
+  end
+end

data/lib/railswatch/extensions/trace_db.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Extensions
+    module Db
+      # in env
+      # this works if config.log_level = :debug
+      def sql(event)
+        sql_text = event.payload[:sql].to_s
+        return super if sql_text.match?(/\brailswatch_/i)
+
+        CurrentRequest.current.trace({
+                                       group: :db,
+                                       duration: event.duration.round(2),
+                                       sql: sql_text
+                                     })
+        super
+      end
+    end
+  end
+end

data/lib/railswatch/gems/custom_ext.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Gems
+    module CustomExtension
+      module_function
+
+      def measure(tag_name, namespace_name = nil, &)
+        return yield unless Railswatch.enabled && Railswatch.include_custom_events
+
+        now = Railswatch::Utils.time
+        status = 'success'
+        execute_with_status(&)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        status = 'error'
+        raise(e)
+      ensure
+        save_custom_record(tag_name, namespace_name, status, now)
+        CurrentRequest.cleanup
+      end
+
+      def execute_with_status
+        yield
+      end
+
+      def save_custom_record(tag_name, namespace_name, status, now)
+        Railswatch::Models::CustomRecord.new(
+          tag_name: tag_name,
+          namespace_name: namespace_name,
+          status: status,
+          duration: (Railswatch::Utils.time - now) * 1000,
+          datetime: now.strftime(Railswatch::FORMAT),
+          datetimei: now.to_i
+        ).save
+      end
+    end
+  end
+end