railswatch 1.0.0

data/lib/railswatch/gems/delayed_job_ext.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Gems
+    class DelayedJobExt
+      class Plugin < ::Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job) do |job, *args, &block|
+            now = Railswatch::Utils.time
+            error = nil
+            block.call(job, *args)
+            status = 'success'
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            status = 'error'
+            error = e
+            raise e
+          ensure
+            Railswatch::Gems::DelayedJobExt::Plugin.persist(job, now, status, error)
+          end
+        end
+
+        def self.persist(job, now, status, error) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          meta_data = meta(job.payload_object)
+          error_bt = error ? error.backtrace&.take(20)&.join("\n") : nil
+          record = Railswatch::Models::DelayedJobRecord.new(
+            jid: job.id,
+            duration: (Railswatch::Utils.time - now) * 1000,
+            datetime: now.strftime(Railswatch::FORMAT),
+            datetimei: now.to_i,
+            source_type: meta_data[0],
+            class_name: meta_data[1],
+            method_name: meta_data[2],
+            status: status,
+            job_args: filtered_args(job.payload_object),
+            error_message: error&.message,
+            error_backtrace: error_bt
+          )
+          record.save
+          CurrentRequest.cleanup
+        end
+
+        # [source_type, class_name, method_name]
+        def self.meta(payload_object) # rubocop:disable Metrics/MethodLength
+          if payload_object.is_a?(::Delayed::PerformableMethod)
+            if payload_object.object.is_a?(Module)
+              [:class_method, payload_object.object.name, payload_object.method_name.to_s]
+            else
+              [:instance_method, payload_object.object.class.name, payload_object.method_name.to_s]
+            end
+          else
+            [:instance_method, payload_object.class.name, 'perform']
+          end
+        rescue StandardError
+          %i[unknown unknown unknown]
+        end
+
+        def self.filtered_args(payload_object)
+          raw = payload_object.args if payload_object.respond_to?(:args)
+          Railswatch::Utils.filter_params({ 'args' => Array.wrap(raw) })['args']
+        rescue StandardError
+          nil
+        end
+      end
+
+      def self.init
+        ::Delayed::Worker.plugins += [::Railswatch::Gems::DelayedJobExt::Plugin]
+      end
+    end
+  end
+end

data/lib/railswatch/gems/grape_ext.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Gems
+    class GrapeExt
+      class << self
+        def init
+          ActiveSupport::Notifications.subscribe(/grape/) do |name, start, finish, _id, payload|
+            handle_grape_notification(name, start, finish, payload)
+          end
+        end
+
+        def handle_grape_notification(name, start, finish, payload)
+          req = setup_grape_request
+          now = Railswatch::Utils.time
+          set_record_fields(req, now)
+          set_timing_field(req.record, name, start, finish)
+          set_payload_fields(req.record, payload[:env]) if payload[:env]
+          save_and_cleanup_if_needed(req, name, payload)
+        end
+
+        def setup_grape_request
+          req = CurrentRequest.current
+          req.ignore.add(:monitoring)
+          req.data ||= {}
+          req.record ||= Railswatch::Models::GrapeRecord.new(request_id: req.request_id)
+          req
+        end
+
+        def set_record_fields(req, now)
+          req.record.datetimei ||= now.to_i
+          req.record.datetime ||= now.strftime(Railswatch::FORMAT)
+        end
+
+        def save_and_cleanup_if_needed(req, name, payload)
+          return unless name == 'format_response.grape' || name_grape_expect_no_content?(req, name, payload)
+
+          req.record.save
+          CurrentRequest.cleanup
+        end
+
+        def name_grape_expect_no_content?(req, name, payload)
+          expects_no_content = Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(req.record.status.to_i)
+          name == 'endpoint_run.grape' && (payload[:endpoint]&.body.nil? || expects_no_content)
+        end
+
+        def set_timing_field(record, name, start, finish)
+          return unless ['endpoint_render.grape', 'endpoint_run.grape', 'format_response.grape'].include?(name)
+
+          record.send("#{name.tr('.', '_')}=", (finish - start) * 1000)
+        end
+
+        def set_payload_fields(record, env)
+          endpoint = env['api.endpoint']
+
+          record.status = endpoint&.status || env['api.response.status']
+          record.format = env['api.format']
+          record.method = env['REQUEST_METHOD']
+          record.path = env['PATH_INFO']
+        end
+      end
+    end
+  end
+end

data/lib/railswatch/gems/rake_ext.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Gems
+    class RakeExt
+      class << self
+        def init # rubocop:disable Metrics/MethodLength
+          ::Rake::Task.class_eval do
+            next if method_defined?(:invoke_with_railswatch)
+
+            def invoke_with_railswatch(*args)
+              now = Railswatch::Utils.time
+              status = 'success'
+              invoke_without_new_railswatch(*args)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              status = 'error'
+              raise(e)
+            ensure
+              Railswatch::Gems::RakeExt.store_invocation(self, args, now, status)
+            end
+
+            alias_method :invoke_without_new_railswatch, :invoke
+            alias_method :invoke, :invoke_with_railswatch
+
+            def invoke(*args) # rubocop:disable Lint/DuplicateMethods
+              invoke_with_railswatch(*args)
+            end
+          end
+        end
+
+        def find_task_name(*args)
+          (ARGV + args).compact
+        end
+
+        def store_invocation(task, args, started_at, status)
+          return if Railswatch.skipable_rake_tasks.include?(task.name)
+          return unless monitoring_storage_available?
+
+          build_rake_record(task, args, started_at, status).save
+        ensure
+          CurrentRequest.cleanup
+        end
+
+        def resolved_task_name(task, args)
+          task_info = find_task_name(*args)
+          task_info.empty? ? [task.name] : task_info
+        end
+
+        def monitoring_storage_available?
+          Railswatch::Models::RakeRecord.connection.data_source_exists?(
+            Railswatch::Models::RakeRecord.table_name
+          )
+        rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+          false
+        end
+
+        def build_rake_record(task, args, started_at, status)
+          Railswatch::Models::RakeRecord.new(
+            task: resolved_task_name(task, args),
+            datetime: started_at.strftime(Railswatch::FORMAT),
+            datetimei: started_at.to_i,
+            duration: (Railswatch::Utils.time - started_at) * 1000,
+            status: status
+          )
+        end
+      end
+    end
+  end
+end

data/lib/railswatch/gems/sidekiq_ext.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Gems
+    class SidekiqExt
+      def initialize(options = nil); end
+
+      def call(worker, msg, queue) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        now = Railswatch::Utils.time
+        payload = msg.is_a?(Hash) ? msg : {}
+        queue_name = queue.respond_to?(:call) ? nil : queue
+        record = build_record(worker, payload, queue_name, now)
+
+        result = yield
+        record.status = 'success'
+        result
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        record.status = 'exception'
+        record.message = e.message
+        record.error_backtrace = e.backtrace&.take(20)&.join("\n")
+        raise e
+      ensure
+        persist_record(record, now)
+      end
+
+      private
+
+      def persist_record(record, started_at)
+        return unless record
+
+        record.duration = (Railswatch::Utils.time - started_at) * 1000
+        record.save
+        CurrentRequest.cleanup
+      end
+
+      def build_record(worker, payload, queue_name, now) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        filtered = Railswatch::Utils.filter_params({ 'args' => Array.wrap(payload['args']) })
+        Railswatch::Models::SidekiqRecord.new(
+          enqueued_ati: present_to_i(payload['enqueued_at']),
+          datetimei: present_to_i(payload['created_at']),
+          jid: payload['jid'].presence || SecureRandom.hex(12),
+          queue: queue_name.presence || 'default',
+          start_timei: now.to_i,
+          datetime: now.strftime(Railswatch::FORMAT),
+          worker: payload['wrapped'].presence || worker.to_s,
+          job_args: filtered['args']
+        )
+      end
+
+      def present_to_i(val)
+        val.present? ? val.to_i : nil
+      end
+    end
+  end
+end

data/lib/railswatch/instrument/metrics_collector.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Instrument
+    class MetricsCollector
+      # payload
+      # {
+      #   controller: "PostsController",
+      #   action: "index",
+      #   params: {"action" => "index", "controller" => "posts"},
+      #   headers: #<ActionDispatch::Http::Headers:0x0055a67a519b88>,
+      #   format: :html,
+      #   method: "GET",
+      #   path: "/posts",
+      #   status: 200,
+      #   view_runtime: 46.848,
+      #   db_runtime: 0.157
+      # }
+
+      def call(event_name, started, finished, event_id, payload)
+        return if Railswatch.skip
+        return if CurrentRequest.current.data
+
+        return if ignored_event?(payload)
+
+        CurrentRequest.current.data = build_record(
+          event_name: event_name,
+          started: started,
+          finished: finished,
+          event_id: event_id,
+          payload: payload
+        )
+      end
+
+      private
+
+      def ignored_event?(payload)
+        return true if payload[:controller].blank?
+
+        endpoint = "#{payload[:controller]}##{payload[:action]}"
+        Railswatch.ignored_endpoints.include?(endpoint) ||
+          Railswatch.ignored_paths.any? { |path| payload[:path].start_with?(path) }
+      end
+
+      def build_record(event_name:, started:, finished:, event_id:, payload:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        event = notification_event(event_name, started, finished, event_id, payload)
+        finished_at = finished.is_a?(Time) ? finished.utc : Time.at(finished).utc
+        {
+          controller: payload[:controller],
+          action: payload[:action],
+          format: payload[:format],
+          status: payload[:status],
+          datetime: finished_at.strftime(Railswatch::FORMAT),
+          datetimei: finished_at.to_i,
+          method: payload[:method],
+          path: payload[:path],
+          view_runtime: payload[:view_runtime],
+          db_runtime: payload[:db_runtime],
+          duration: event.duration,
+          exception: payload[:exception],
+          exception_object: payload[:exception_object]
+        }
+      end
+
+      def notification_event(event_name, started, finished, event_id, payload)
+        ActiveSupport::Notifications::Event.new(event_name, started, finished, event_id, payload)
+      end
+    end
+  end
+end

data/lib/railswatch/interface.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Interface
+    def create_event(name:, datetime: Railswatch::Utils.time, options: {})
+      Railswatch::Events::Record.create(name: name, datetimei: datetime.to_i, options: options)
+    end
+  end
+end

data/lib/railswatch/models/application_record.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+
+      class << self
+        def reset_storage_connection!
+          target = Railswatch.database_connection_name.presence&.to_s
+          if target.blank?
+            remove_connection
+          else
+            establish_connection(resolve_connection_name(target).to_sym)
+          end
+        rescue ActiveRecord::ConnectionNotEstablished
+          nil
+        end
+
+        private
+
+        def resolve_connection_name(target)
+          configs = ActiveRecord::Base.configurations.configs_for(env_name: ::Rails.env)
+          return target if configs.any? { |config| config.name == target }
+
+          "#{::Rails.env}_#{target}"
+        end
+      end
+    end
+  end
+end

data/lib/railswatch/models/base_record.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Railswatch
+  module Models
+    class BaseRecord < ApplicationRecord
+      self.abstract_class = true
+
+      before_validation :normalize_occurred_at!
+
+      def datetime
+        occurred_at&.utc&.strftime(Railswatch::FORMAT)
+      end
+
+      def datetime=(value)
+        @legacy_datetime = value
+      end
+
+      def datetimei
+        occurred_at&.to_i
+      end
+
+      def datetimei=(value)
+        @legacy_datetimei = value&.to_i
+      end
+
+      def value
+        payload_hash
+      end
+
+      def duration
+        value['duration']
+      end
+
+      private
+
+      def payload_hash
+        {}
+      end
+
+      def ms(value)
+        "#{value.to_f.round(1)} ms" if value
+      end
+
+      def normalize_occurred_at!
+        self.occurred_at ||= if @legacy_datetimei.present?
+                               Time.at(@legacy_datetimei, in: '+00:00')
+                             elsif @legacy_datetime.present?
+                               Time.strptime(@legacy_datetime, Railswatch::FORMAT).utc
+                             else
+                               Railswatch::Utils.time
+                             end
+      rescue ArgumentError
+        self.occurred_at ||= Railswatch::Utils.time
+      end
+    end
+  end
+end

data/lib/railswatch/models/collection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class Collection
+      attr_reader :data
+
+      def initialize
+        @data = []
+      end
+
+      def add(record)
+        @data << record
+      end
+
+      def group_by(type)
+        case type
+        when :controller_action, :controller_action_format, :datetime, :path
+          fetch_values @data.group_by(&type)
+        else
+          {}
+        end
+      end
+
+      def fetch_values(groupped_collection)
+        result = {}
+        groupped_collection.each do |key, records|
+          result[key] ||= []
+          records.each do |record|
+            result[key] << record.value
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/railswatch/models/custom_record.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class CustomRecord < BaseRecord
+      self.table_name = 'railswatch_custom_records'
+
+      def duration
+        duration_ms
+      end
+
+      def duration=(value)
+        self.duration_ms = value
+      end
+
+      def payload_hash
+        { 'duration' => duration_ms }
+      end
+
+      def record_hash
+        {
+          tag_name: tag_name,
+          namespace_name: namespace_name,
+          status: status,
+          datetimei: occurred_at.to_i,
+          datetime: occurred_at,
+          duration: duration_ms
+        }
+      end
+    end
+  end
+end

data/lib/railswatch/models/delayed_job_record.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class DelayedJobRecord < BaseRecord
+      self.table_name = 'railswatch_delayed_job_records'
+
+      serialize :job_args, coder: JSON
+
+      def duration
+        duration_ms
+      end
+
+      def duration=(value)
+        self.duration_ms = value
+      end
+
+      def payload_hash
+        { 'duration' => duration_ms }
+      end
+
+      def record_hash # rubocop:disable Metrics/MethodLength
+        {
+          jid: jid,
+          datetime: occurred_at,
+          datetimei: occurred_at.to_i,
+          duration: duration_ms,
+          status: status,
+          source_type: source_type,
+          class_name: class_name,
+          method_name: method_name,
+          job_args: job_args,
+          error_message: error_message,
+          error_backtrace: error_backtrace
+        }
+      end
+    end
+  end
+end

data/lib/railswatch/models/event_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class EventRecord < BaseRecord
+      self.table_name = 'railswatch_event_records'
+
+      serialize :options, coder: JSON
+    end
+  end
+end

data/lib/railswatch/models/grape_record.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class GrapeRecord < BaseRecord
+      self.table_name = 'railswatch_grape_records'
+
+      def method
+        http_method
+      end
+
+      def method=(value)
+        self.http_method = value
+      end
+
+      def endpoint_render_grape
+        endpoint_render_grape_ms
+      end
+
+      def endpoint_render_grape=(value)
+        self.endpoint_render_grape_ms = value
+      end
+
+      def endpoint_run_grape
+        endpoint_run_grape_ms
+      end
+
+      def endpoint_run_grape=(value)
+        self.endpoint_run_grape_ms = value
+      end
+
+      def format_response_grape
+        format_response_grape_ms
+      end
+
+      def format_response_grape=(value)
+        self.format_response_grape_ms = value
+      end
+
+      def payload_hash
+        {
+          'endpoint_render.grape' => endpoint_render_grape_ms,
+          'endpoint_run.grape' => endpoint_run_grape_ms,
+          'format_response.grape' => format_response_grape_ms
+        }
+      end
+
+      def record_hash
+        {
+          format: self.format,
+          status: status,
+          method: http_method,
+          path: path,
+          datetime: occurred_at,
+          datetimei: occurred_at.to_i,
+          request_id: request_id
+        }.merge(payload_hash)
+      end
+    end
+  end
+end

data/lib/railswatch/models/rake_record.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Railswatch
+  module Models
+    class RakeRecord < BaseRecord
+      self.table_name = 'railswatch_rake_records'
+
+      serialize :task, coder: JSON
+
+      def duration
+        duration_ms
+      end
+
+      def duration=(value)
+        self.duration_ms = value
+      end
+
+      def payload_hash
+        { 'duration' => duration_ms }
+      end
+
+      def record_hash
+        {
+          task: Array.wrap(task),
+          datetime: occurred_at,
+          datetimei: occurred_at.to_i,
+          duration: duration_ms,
+          status: status
+        }
+      end
+    end
+  end
+end