railswatch 1.0.0

data/lib/railswatch/reports/resources_report.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Reports
+    class ResourcesReport < BaseReport
+      Server = Struct.new(:report, :key) do
+        def name
+          key.split('///').join(', ')
+        end
+
+        def charts
+          Railswatch.system_monitors.map do |class_name|
+            Widgets.const_get(class_name).new(self)
+          end
+        end
+      end
+
+      def servers
+        data.keys.map { |key| Server.new(self, key) }
+      end
+
+      def extract_signal(&block)
+        data.transform_values do |records|
+          prepare_report(records.to_h do |entry|
+                           [entry[:datetimei] * 1000, block.call(entry)]
+                         end)
+        end
+      end
+
+      private
+
+      def data
+        @data ||= db.order(:occurred_at).map(&:record_hash)
+                    .group_by { |entry| "#{entry[:server]}///#{entry[:context]}///#{entry[:role]}" }
+      end
+
+      def prepare_report(input)
+        nullify_data(input, Railswatch.system_monitor_duration)
+      end
+    end
+  end
+end

data/lib/railswatch/reports/response_time_report.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Reports
+    class ResponseTimeReport < BaseReport
+      def data
+        averages = grouped_durations.transform_values { |values| values.sum.to_f / values.count }
+        nullify_data(averages).map { |x, y| [x, y&.round(2) || 0] }
+      end
+
+      private
+
+      def grouped_durations
+        db.pluck(:occurred_at, :duration_ms).each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |row, buckets|
+          occurred_at, duration_ms = row
+          next if duration_ms.nil?
+
+          buckets[bucket_key(occurred_at)] << duration_ms
+        end
+      end
+
+      def bucket_key(occurred_at)
+        occurred_at.change(sec: 0, usec: 0).to_i * 1000
+      end
+    end
+  end
+end

data/lib/railswatch/reports/slow_requests_report.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Reports
+    class SlowRequestsReport < BaseReport
+      def data
+        db.where('occurred_at > ?', Railswatch.slow_requests_time_window.ago)
+          .where('duration_ms > ?', Railswatch.slow_requests_threshold.to_f)
+          .order(occurred_at: :desc)
+          .limit(limit)
+          .map(&:record_hash)
+      end
+
+      private
+
+      def limit
+        Railswatch.slow_requests_limit ? Railswatch.slow_requests_limit.to_i : 100_000
+      end
+    end
+  end
+end

data/lib/railswatch/reports/throughput_report.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Reports
+    class ThroughputReport < BaseReport
+      def data
+        series = db.pluck(:occurred_at).each_with_object(Hash.new(0)) do |occurred_at, buckets|
+          bucket = occurred_at.change(sec: 0, usec: 0).to_i * 1000
+          buckets[bucket] += 1
+        end
+
+        nullify_data(series.transform_values(&:to_f)).map { |x, y| [x, (y || 0).round(2)] }
+      end
+    end
+  end
+end

data/lib/railswatch/reports/trace_report.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Reports
+    class TraceReport
+      attr_reader :request_id
+
+      def initialize(request_id:)
+        @request_id = request_id
+      end
+
+      def data
+        Railswatch::Models::TraceRecord.find_by(request_id: request_id)&.value || []
+      end
+    end
+  end
+end

data/lib/railswatch/system_monitor/resources_monitor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module SystemMonitor
+    class ResourcesMonitor
+      attr_reader :context, :role
+
+      def initialize(context, role)
+        @context = context
+        @role = role
+        @mutex = Mutex.new
+        @thread = nil
+
+        return unless Railswatch._resource_monitor_enabled
+
+        start_monitoring
+      end
+
+      def start_monitoring
+        @mutex.synchronize do
+          return if @thread
+
+          @thread = Thread.new { monitor_loop }
+        end
+      end
+
+      def stop_monitoring
+        @mutex.synchronize do
+          return unless @thread
+
+          @thread.kill
+          @thread = nil
+        end
+      end
+
+      def payload
+        monitors.reduce({}) do |data, monitor|
+          data.merge(monitor.key => monitor.measure)
+        end
+      end
+
+      def monitors
+        @monitors ||= Railswatch.system_monitors.map do |class_name|
+          Railswatch::Widgets.const_get(class_name).new(nil)
+        end
+      end
+
+      def run
+        store_data(payload)
+      end
+
+      def store_data(data) # rubocop:disable Metrics/MethodLength
+        now = Railswatch::Utils.kind_of_now
+        now = now.change(sec: 0, usec: 0)
+
+        Railswatch.log(resource_log_message(data))
+        Railswatch::Models::ResourceRecord.new(
+          server: server_id,
+          context: context,
+          role: role,
+          datetime: now.strftime(Railswatch::FORMAT),
+          datetimei: now.to_i,
+          json: data
+        ).save
+      end
+
+      def server_id
+        @server_id ||= ENV['RAILSWATCH_SERVER_ID'] || `hostname`.strip
+      end
+
+      private
+
+      def monitor_loop
+        loop do
+          run
+        rescue StandardError => e
+          ::Rails.logger.error "Monitor error: #{e.message}"
+        ensure
+          sleep 60
+        end
+      end
+
+      def resource_log_message(data)
+        "Server: #{server_id}, Context: #{context}, Role: #{role}, data: #{data}"
+      end
+    end
+  end
+end

data/lib/railswatch/thread/current_request.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Railswatch
+  class CurrentRequest
+    attr_reader :request_id, :tracings, :ignore
+    attr_accessor :data, :record
+
+    def self.init
+      Thread.current[:rp_current_request] ||= CurrentRequest.new(SecureRandom.hex(16))
+    end
+
+    def self.current
+      CurrentRequest.init
+    end
+
+    def self.cleanup
+      Railswatch.log(
+        '----------------------------------------------------> ' \
+        "CurrentRequest.cleanup !!!!!!!!!!!! -------------------------\n\n"
+      )
+      Railswatch.skip = false
+      Thread.current[:rp_current_request] = nil
+    end
+
+    def initialize(request_id)
+      @request_id = request_id
+      @tracings = []
+      @ignore = Set.new
+      @data = nil
+      @record = nil
+    end
+
+    def trace(options = {})
+      @tracings << options.merge(time: Railswatch::Utils.time.to_i)
+    end
+  end
+end

data/lib/railswatch/utils.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Railswatch
+  class Utils
+    DEFAULT_TIME_OFFSET = 1.minute
+
+    def self.time
+      Time.now.utc
+    end
+
+    def self.kind_of_now
+      time + DEFAULT_TIME_OFFSET
+    end
+
+    def self.from_datetimei(datetimei)
+      Time.at(datetimei, in: '+00:00')
+    end
+
+    def self.days(duration = Railswatch.duration)
+      (duration / 1.day) + 1
+    end
+
+    def self.median(array)
+      sorted = array.sort
+      size = sorted.size
+      center = size / 2
+
+      if size.zero?
+        nil
+      elsif size.even?
+        (sorted[center - 1] + sorted[center]) / 2.0
+      else
+        sorted[center]
+      end
+    end
+
+    def self.percentile(values, percentile)
+      return nil if values.empty?
+
+      sorted = values.sort
+      rank = (percentile.to_f / 100) * (sorted.size - 1)
+
+      lower = sorted[rank.floor]
+      upper = sorted[rank.ceil]
+      lower + ((upper - lower) * (rank - rank.floor))
+    end
+
+    def self.filter_params(params)
+      return {} if params.blank?
+      return {} unless defined?(::Rails) && ::Rails.application
+
+      filter = ActiveSupport::ParameterFilter.new(::Rails.application.config.filter_parameters)
+      filter.filter(params.to_h)
+    rescue StandardError
+      {}
+    end
+  end
+end

data/lib/railswatch/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Railswatch
+  VERSION = '1.0.0'
+  SCHEMA = '1.0.0'
+  EVENTS_SCHEMA = '1.0.0'
+end

data/lib/railswatch/widgets/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class Base
+      attr_reader :datasource
+
+      def initialize(datasource)
+        @datasource = datasource
+      end
+
+      def to_partial_path
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/card.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class Card < Base
+      def label
+        raise NotImplementedError
+      end
+
+      def value
+        raise NotImplementedError
+      end
+
+      def to_partial_path
+        'railswatch/railswatch/card'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/chart.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class Chart < Base
+      attr_accessor :subtitle, :description, :legend, :units
+
+      def initialize(datasource, subtitle: nil, description: nil, legend: nil, units: nil)
+        super(datasource)
+        @subtitle = subtitle
+        @description = description
+        @legend = legend
+        @units = units
+      end
+
+      def id
+        raise NotImplementedError
+      end
+
+      def type
+        raise NotImplementedError
+      end
+
+      def data
+        raise NotImplementedError
+      end
+
+      def to_partial_path
+        'railswatch/railswatch/chart'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/crashes_table.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class CrashesTable < Table
+      def subtitle
+        'Crash Report'
+      end
+
+      def data
+        @data ||= Railswatch::Reports::CrashReport.new(datasource.db).data
+      end
+
+      def empty_message
+        'We are glad that this list is empty ;)'
+      end
+
+      def table_classes
+        'table is-fullwidth is-hoverable is-narrow'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/crashes_table_content'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/custom_events_table.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class CustomEventsTable < Table
+      def subtitle
+        "Recent Events (last #{Railswatch.recent_requests_time_window / 60} minutes)"
+      end
+
+      def data
+        @data ||= Railswatch::Reports::RecentRequestsReport.new(datasource.db).data
+      end
+
+      def empty_message
+        example_message.html_safe
+      end
+
+      def example_message
+        <<~HTML
+          Nothing to show here. Try to make a few requests in the main app.
+
+          <pre>
+            <code>
+              # in controller for example
+              def index
+                Railswatch.measure("stats calculation", "reports#index") do
+                  stats = User.calculate_stats
+                end
+              end
+            </code>
+          </pre>
+        HTML
+      end
+
+      def show_export?
+        false
+      end
+
+      def table_classes
+        'table is-fullwidth is-hoverable is-narrow'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/custom_events_table_content'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/delayed_job_table.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class DelayedJobTable < Table
+      def subtitle
+        "Recent Jobs (last #{Railswatch.recent_requests_time_window / 60} minutes)"
+      end
+
+      def data
+        @data ||= Railswatch::Reports::RecentRequestsReport.new(datasource.db).data
+      end
+
+      def empty_message
+        'Nothing to show here. Try to make a few requests in the main app.'
+      end
+
+      def show_export?
+        false
+      end
+
+      def table_classes
+        'table is-fullwidth is-hoverable is-narrow'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/delayed_job_table_content'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/grape_requests_table.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class GrapeRequestsTable < Table
+      def subtitle
+        "Recent Requests (last #{Railswatch.recent_requests_time_window / 60} minutes)"
+      end
+
+      def data
+        @data ||= Railswatch::Reports::RecentRequestsReport.new(datasource.db).data
+      end
+
+      def empty_message
+        'Nothing to show here. Try to make a few requests in the main app.'
+      end
+
+      def show_export?
+        false
+      end
+
+      def table_classes
+        'table is-fullwidth is-hoverable is-narrow'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/grape_requests_table_content'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/percentile_card.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class PercentileCard < Card
+      def value
+        Reports::PercentileReport.new(datasource.db).data[label.to_sym]
+      end
+    end
+
+    class P50Card < PercentileCard
+      def label = 'p50'
+    end
+
+    class P95Card < PercentileCard
+      def label = 'p95'
+    end
+
+    class P99Card < PercentileCard
+      def label = 'p99'
+    end
+  end
+end

data/lib/railswatch/widgets/rake_tasks_table.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class RakeTasksTable < Table
+      def subtitle
+        "Recent Rake tasks (last #{Railswatch.recent_requests_time_window / 60} minutes)"
+      end
+
+      def data
+        @data ||= Railswatch::Reports::RecentRequestsReport.new(datasource.db).data
+      end
+
+      def empty_message
+        'Nothing to show here. Try to make a few requests in the main app.'
+      end
+
+      def show_export?
+        false
+      end
+
+      def table_classes
+        'table is-fullwidth is-hoverable is-narrow'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/rake_tasks_table_content'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/recent_requests_table.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class RecentRequestsTable < Table
+      def subtitle
+        "Recent Requests (last #{Railswatch.recent_requests_time_window / 60} minutes)"
+      end
+
+      def data
+        @data ||= Railswatch::Reports::RecentRequestsReport.new(datasource.db).data
+      end
+
+      def empty_message
+        'Nothing to show here. Try to make a few requests in the main app.'
+      end
+
+      def auto_update_interval
+        '3s'
+      end
+
+      def table_id
+        'recent'
+      end
+
+      def table_classes
+        'table is-fullwidth is-hoverable is-narrow'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/recent_requests_table_content'
+      end
+    end
+  end
+end

data/lib/railswatch/widgets/requests_table.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Widgets
+    class RequestsTable < Table
+      def subtitle
+        'Requests Analysis'
+      end
+
+      def data
+        @data ||= Railswatch::Reports::RequestsReport.new(
+          datasource.db,
+          group: :controller_action_format,
+          sort: :count
+        ).data
+      end
+
+      def empty_message
+        'No requests recorded yet.'
+      end
+
+      def content_partial_path
+        'railswatch/railswatch/requests_table_content'
+      end
+    end
+  end
+end