RubyGems - error_radar - Versions diffs - 0.1.0 - Mend

error_radar 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

checksums.yaml +7 -0
data/CHANGELOG.md +11 -0
data/MIT-LICENSE +20 -0
data/README.md +106 -0
data/Rakefile +5 -0
data/app/controllers/error_radar/application_controller.rb +23 -0
data/app/controllers/error_radar/dashboard_controller.rb +82 -0
data/app/models/error_radar/application_record.rb +7 -0
data/app/models/error_radar/error_log.rb +95 -0
data/app/views/error_radar/dashboard/index.html.erb +185 -0
data/app/views/error_radar/dashboard/show.html.erb +72 -0
data/app/views/layouts/error_radar/application.html.erb +48 -0
data/config/routes.rb +7 -0
data/lib/error_radar/configuration.rb +81 -0
data/lib/error_radar/engine.rb +33 -0
data/lib/error_radar/integrations/active_job.rb +32 -0
data/lib/error_radar/integrations/rails_admin.rb +145 -0
data/lib/error_radar/integrations/sidekiq.rb +35 -0
data/lib/error_radar/middleware.rb +53 -0
data/lib/error_radar/server_monitor.rb +94 -0
data/lib/error_radar/tracking.rb +116 -0
data/lib/error_radar/version.rb +5 -0
data/lib/error_radar.rb +47 -0
data/lib/generators/error_radar/install/install_generator.rb +38 -0
data/lib/generators/error_radar/install/templates/create_error_radar_error_logs.rb.tt +45 -0
data/lib/generators/error_radar/install/templates/initializer.rb +45 -0
metadata +108 -0

data/app/views/layouts/error_radar/application.html.erb ADDED Viewed

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Error Radar</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <!-- Chart.js (charts) + SortableJS (kanban drag-drop), loaded from CDN -->
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/sortablejs@1.15.2/Sortable.min.js"></script>
+    <style>
+      * { box-sizing: border-box; }
+      body { margin: 0; font-family: -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; background: #f4f6f8; color: #1f2933; }
+      .wrap { max-width: 1360px; margin: 0 auto; padding: 20px; }
+      h1 { font-size: 22px; margin: 0 0 4px; }
+      .sub { color: #6b7280; font-size: 13px; margin-bottom: 18px; }
+      a { color: #2563eb; text-decoration: none; }
+      .cards { display: grid; grid-template-columns: repeat(5, 1fr); gap: 12px; margin-bottom: 20px; }
+      .card { background: #fff; border-radius: 10px; padding: 16px; box-shadow: 0 1px 3px rgba(0,0,0,.08); }
+      .card .n { font-size: 28px; font-weight: 700; }
+      .card .l { font-size: 12px; color: #6b7280; text-transform: uppercase; letter-spacing: .04em; }
+      .card.open .n { color: #dc3545; } .card.prog .n { color: #fd7e14; }
+      .card.res .n { color: #28a745; } .card.ign .n { color: #6c757d; } .card.tot .n { color: #1f2933; }
+      .grid2 { display: grid; grid-template-columns: 2fr 1fr; gap: 16px; margin-bottom: 20px; }
+      .panel { background: #fff; border-radius: 10px; padding: 16px; box-shadow: 0 1px 3px rgba(0,0,0,.08); }
+      .panel h2 { font-size: 14px; margin: 0 0 12px; color: #374151; }
+      table { width: 100%; border-collapse: collapse; font-size: 13px; }
+      th, td { text-align: left; padding: 6px 8px; border-bottom: 1px solid #eef0f2; }
+      .badge { display: inline-block; padding: 2px 8px; border-radius: 10px; color: #fff; font-size: 11px; }
+      .kanban { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; }
+      .col { background: #eceff1; border-radius: 10px; padding: 10px; min-height: 200px; }
+      .col h3 { font-size: 13px; margin: 0 0 10px; display: flex; justify-content: space-between; }
+      .col .count { background: #cfd8dc; border-radius: 8px; padding: 0 8px; font-size: 12px; }
+      .ticket { background: #fff; border-radius: 8px; padding: 10px; margin-bottom: 8px; box-shadow: 0 1px 2px rgba(0,0,0,.1); cursor: grab; border-left: 4px solid #9ca3af; }
+      .ticket.sev-critical { border-left-color: #7b001c; } .ticket.sev-error { border-left-color: #dc3545; }
+      .ticket.sev-warning { border-left-color: #fd7e14; } .ticket.sev-info { border-left-color: #17a2b8; }
+      .ticket .src { font-weight: 600; font-size: 12px; word-break: break-all; }
+      .ticket .msg { font-size: 12px; color: #4b5563; margin: 4px 0; max-height: 48px; overflow: hidden; }
+      .ticket .meta { font-size: 11px; color: #9ca3af; display: flex; gap: 8px; flex-wrap: wrap; }
+      .ticket .occ { background: #fee2e2; color: #b91c1c; border-radius: 8px; padding: 0 6px; }
+      .toast { position: fixed; bottom: 20px; right: 20px; background: #1f2933; color: #fff; padding: 10px 16px; border-radius: 8px; opacity: 0; transition: opacity .2s; }
+      .toast.show { opacity: 1; }
+    </style>
+  </head>
+  <body>
+    <div class="wrap"><%= yield %></div>
+    <div id="toast" class="toast"></div>
+  </body>
+</html>

data/config/routes.rb ADDED Viewed

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+ErrorRadar::Engine.routes.draw do
+  root to: 'dashboard#index'
+  get   'errors/:id',        to: 'dashboard#show',          as: :error
+  patch 'errors/:id/status', to: 'dashboard#update_status', as: :error_status
+end

data/lib/error_radar/configuration.rb ADDED Viewed

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module ErrorRadar
+  # Holds every host-app-specific decision so the engine stays decoupled.
+  # Configure from an initializer (see the install generator's template).
+  class Configuration
+    # Master switch — set false (e.g. in test env) to make capture a no-op.
+    attr_accessor :enabled
+    # How many backtrace lines to persist.
+    attr_accessor :backtrace_lines
+    # Truncate stored messages to this many chars.
+    attr_accessor :max_message_length
+    # Exception class names the Rack middleware must NOT log (expected client
+    # outcomes: routing errors, 404s, bad requests, ...).
+    attr_accessor :ignored_exceptions
+    # Request param keys to scrub before persisting them in `context`.
+    attr_accessor :sensitive_params
+    # Integration toggles.
+    attr_accessor :install_middleware, :install_sidekiq, :install_rails_admin
+    # Custom classification rules. Each is a callable `->(exception) { :category | nil }`.
+    # The first rule that returns a non-nil category wins; built-in rules run after.
+    attr_accessor :categorizers
+    # Extract extra structured columns from custom exception types. Each is a
+    # callable `->(exception) { { http_status:, request_url:, api_code:, api_subcode: } | nil }`.
+    attr_accessor :detail_extractors
+    # Optional Sidekiq process expectations for the dashboard's server panel.
+    # Each entry: { key:, name:, tag:, host:, queue_hint: }. Empty => the panel
+    # simply lists whatever live processes exist.
+    attr_accessor :expected_servers
+    # Dashboard auth: `->(controller) { ... }` run as a before_action. Raise /
+    # redirect inside it to deny access. nil => no auth (NOT recommended in prod).
+    attr_accessor :authenticate
+    # `->(controller) { "who@acted" }` — stamped onto resolved errors.
+    attr_accessor :current_user
+    def initialize
+      @enabled            = true
+      @backtrace_lines    = 30
+      @max_message_length = 4_000
+      @ignored_exceptions = %w[
+        ActionController::RoutingError
+        ActiveRecord::RecordNotFound
+        ActionController::ParameterMissing
+        ActionController::UnknownFormat
+        ActionController::BadRequest
+        ActionController::InvalidAuthenticityToken
+        ActionDispatch::Http::Parameters::ParseError
+      ]
+      @sensitive_params   = %w[password password_confirmation token access_token authorization secret]
+      @install_middleware = true
+      @install_sidekiq    = true
+      @install_rails_admin = true
+      @categorizers       = []
+      @detail_extractors  = []
+      @expected_servers   = []
+      @authenticate       = nil
+      @current_user       = nil
+    end
+    # Convenience DSL inside `configure`:
+    #   c.categorize { |e| :external_api if e.is_a?(MyApi::Error) }
+    def categorize(&block)
+      @categorizers << block
+    end
+    #   c.extract_details { |e| { http_status: e.status } if e.is_a?(MyApi::Error) }
+    def extract_details(&block)
+      @detail_extractors << block
+    end
+  end
+end

data/lib/error_radar/engine.rb ADDED Viewed

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'rails/engine'
+module ErrorRadar
+  class Engine < ::Rails::Engine
+    isolate_namespace ErrorRadar
+    # Capture all unhandled web-layer exceptions. Run after the host's
+    # config/initializers so ErrorRadar.configure has already executed.
+    initializer 'error_radar.middleware', after: :load_config_initializers do |app|
+      if ErrorRadar.config.install_middleware
+        app.middleware.insert_after ActionDispatch::DebugExceptions, ErrorRadar::Middleware
+      end
+    end
+    # Capture every Sidekiq job failure (incl. retries) as an ErrorLog task.
+    initializer 'error_radar.sidekiq', after: :load_config_initializers do
+      if ErrorRadar.config.install_sidekiq && defined?(::Sidekiq)
+        require 'error_radar/integrations/sidekiq'
+        ErrorRadar::Integrations::Sidekiq.install!
+      end
+    end
+    # Register the ErrorLog board + custom actions in RailsAdmin, if present.
+    config.after_initialize do
+      if ErrorRadar.config.install_rails_admin && defined?(::RailsAdmin)
+        require 'error_radar/integrations/rails_admin'
+        ErrorRadar::Integrations::RailsAdmin.install!
+      end
+    end
+  end
+end

data/lib/error_radar/integrations/active_job.rb ADDED Viewed

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module ErrorRadar
+  module Integrations
+    # Opt-in ActiveJob capture. Include into your ApplicationJob to catch
+    # exceptions from any queue adapter (not just Sidekiq), then re-raise so the
+    # adapter's retry/failure handling is unaffected:
+    #
+    #   class ApplicationJob < ActiveJob::Base
+    #     include ErrorRadar::Integrations::ActiveJob
+    #   end
+    #
+    # NOTE: if you also enable the Sidekiq integration, Sidekiq-backed jobs will
+    # be captured by both — keep only one if you want to avoid double counting.
+    module ActiveJob
+      extend ActiveSupport::Concern
+      included do
+        around_perform do |job, block|
+          block.call
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          ErrorRadar.capture(
+            e,
+            source: job.class.name,
+            context: { args: job.arguments, job_id: job.job_id, queue: job.queue_name }
+          )
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/error_radar/integrations/rails_admin.rb ADDED Viewed

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+module ErrorRadar
+  module Integrations
+    # Registers ErrorRadar::ErrorLog as a first-class RailsAdmin model (a triage
+    # board) plus four member actions: start / resolve / ignore / reopen.
+    # Everything is guarded so a host without RailsAdmin is unaffected.
+    module RailsAdmin
+      MODEL = 'ErrorRadar::ErrorLog'
+      # status -> { update attrs, flash verb, icon }
+      ACTIONS = {
+        start_error_log:   { icon: 'fa-solid fa-person-digging', verb: 'marked in progress', update: { status: :in_progress } },
+        ignore_error_log:  { icon: 'fa-solid fa-ban',            verb: 'ignored',            update: { status: :ignored } },
+        reopen_error_log:  { icon: 'fa-solid fa-rotate-left',    verb: 'reopened',           method: :reopen! },
+        resolve_error_log: { icon: 'fa-solid fa-circle-check',   verb: 'marked resolved',    method: :resolve! }
+      }.freeze
+      def self.install!
+        define_actions!
+        configure_model!
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("RailsAdmin integration failed: #{e.class}: #{e.message}")
+      end
+      def self.define_actions!
+        require 'rails_admin/config/actions'
+        require 'rails_admin/config/actions/base'
+        ACTIONS.each do |name, spec|
+          next if ::RailsAdmin::Config::Actions.find(name)
+          klass = Class.new(::RailsAdmin::Config::Actions::Base) do
+            register_instance_option(:only) { MODEL }
+            register_instance_option(:member) { true }
+            register_instance_option(:http_methods) { %i[get put] }
+            register_instance_option(:link_icon) { spec[:icon] }
+            register_instance_option(:pjax?) { false }
+            register_instance_option(:turbo?) { false }
+            register_instance_option(:controller) do
+              proc do
+                actor = (_current_user.try(:email) rescue nil)
+                if spec[:method] == :resolve!
+                  @object.resolve!(by: actor)
+                elsif spec[:method]
+                  @object.public_send(spec[:method])
+                else
+                  @object.update!(spec[:update])
+                end
+                flash[:notice] = "Error ##{@object.id} #{spec[:verb]}."
+                redirect_to back_or_index
+              end
+            end
+          end
+          const_name = name.to_s.split('_').map(&:capitalize).join
+          ErrorRadar::Integrations::RailsAdmin.const_set(const_name, klass) unless const_defined?(const_name)
+          ::RailsAdmin::Config::Actions.register(name, klass)
+        end
+      end
+      def self.configure_model!
+        ::RailsAdmin.config do |config|
+          config.model MODEL do
+            navigation_label 'Monitoring'
+            navigation_icon 'fa-solid fa-triangle-exclamation'
+            label 'Error / Task'
+            label_plural 'Errors / Tasks'
+            weight(-100)
+            list do
+              scopes %i[unresolved] + [nil] + %i[open in_progress resolved ignored]
+              sort_by :last_seen_at
+              items_per_page 50
+              field :id
+              field :status do
+                pretty_value do
+                  colors = { 'open' => '#dc3545', 'in_progress' => '#fd7e14', 'resolved' => '#28a745', 'ignored' => '#6c757d' }
+                  v = bindings[:object].status
+                  %(<span class="label" style="padding:2px 8px;border-radius:10px;color:#fff;background:#{colors[v] || '#6c757d'}">#{v}</span>).html_safe
+                end
+              end
+              field :severity do
+                pretty_value do
+                  colors = { 'info' => '#17a2b8', 'warning' => '#fd7e14', 'error' => '#dc3545', 'critical' => '#7b001c' }
+                  v = bindings[:object].severity
+                  %(<span class="label" style="padding:2px 8px;border-radius:10px;color:#fff;background:#{colors[v] || '#6c757d'}">#{v}</span>).html_safe
+                end
+              end
+              field :category
+              field :source
+              field :error_class
+              field :message do
+                formatted_value { bindings[:object].short_message }
+              end
+              field :occurrences
+              field :http_status
+              field :last_seen_at
+              field :first_seen_at
+            end
+            show do
+              field :id
+              field :status
+              field :severity
+              field :category
+              field :source
+              field :error_class
+              field :message
+              field :occurrences
+              field :first_seen_at
+              field :last_seen_at
+              field :http_status
+              field :api_code
+              field :api_subcode
+              field :request_url
+              field :context do
+                pretty_value do
+                  %(<pre style="white-space:pre-wrap;max-height:400px;overflow:auto">#{JSON.pretty_generate(bindings[:object].context || {})}</pre>).html_safe
+                end
+              end
+              field :backtrace do
+                pretty_value do
+                  %(<pre style="white-space:pre-wrap;max-height:500px;overflow:auto">#{ERB::Util.html_escape(bindings[:object].backtrace)}</pre>).html_safe
+                end
+              end
+              field :resolved_at
+              field :resolved_by
+              field :resolution_note
+              field :created_at
+              field :updated_at
+            end
+            edit do
+              field :status
+              field :severity
+              field :resolution_note
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/error_radar/integrations/sidekiq.rb ADDED Viewed

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module ErrorRadar
+  module Integrations
+    # Hooks ErrorRadar.capture into Sidekiq's server-side error handler so every
+    # background-job failure becomes an ErrorLog task. Idempotent.
+    module Sidekiq
+      HANDLER = lambda do |exception, ctx, _config = nil|
+        job = (ctx && ctx[:job]) || {}
+        ErrorRadar.capture(
+          exception,
+          source: job['class'] || (ctx && ctx[:context]) || 'Sidekiq',
+          context: {
+            jid: job['jid'],
+            queue: job['queue'],
+            args: job['args'],
+            retry_count: job['retry_count'],
+            failed_at: job['failed_at']
+          }.compact
+        )
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("Sidekiq error_handler failed: #{e.class}: #{e.message}")
+      end
+      def self.install!
+        ::Sidekiq.configure_server do |config|
+          handlers = config.error_handlers
+          handlers << HANDLER unless handlers.include?(HANDLER)
+        end
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("Sidekiq integration failed: #{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/error_radar/middleware.rb ADDED Viewed

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module ErrorRadar
+  # Rack middleware that captures every unhandled web-layer exception as an
+  # ErrorLog, then re-raises so Rails' normal exception rendering still happens.
+  # Inserted just below ActionDispatch::DebugExceptions.
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      @app.call(env)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      capture(e, env) unless ignored?(e)
+      raise
+    end
+    private
+    def ignored?(exception)
+      ErrorRadar.config.ignored_exceptions.include?(exception.class.name)
+    end
+    def capture(exception, env)
+      request = ActionDispatch::Request.new(env)
+      ErrorRadar.capture(
+        exception,
+        source: "#{request.request_method} #{request.path}",
+        context: {
+          controller: env['action_dispatch.request.path_parameters']&.dig(:controller),
+          action: env['action_dispatch.request.path_parameters']&.dig(:action),
+          path: request.fullpath,
+          method: request.request_method,
+          ip: request.remote_ip,
+          params: filtered_params(request)
+        }.compact
+      )
+    rescue StandardError => e
+      ErrorRadar::Tracking.warn_internal("middleware capture failed: #{e.class}: #{e.message}")
+    end
+    def filtered_params(request)
+      request.filtered_parameters.except('controller', 'action').deep_transform_values do |v|
+        v.is_a?(String) && v.length > 500 ? "#{v[0, 500]}…" : v
+      end.tap do |p|
+        ErrorRadar.config.sensitive_params.each { |k| p[k] = '[FILTERED]' if p.key?(k) }
+      end
+    rescue StandardError
+      {}
+    end
+  end
+end

data/lib/error_radar/server_monitor.rb ADDED Viewed

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+module ErrorRadar
+  # Reads the live Sidekiq process registry from Redis and reports whether each
+  # EXPECTED process (configured via ErrorRadar.config.expected_servers) is
+  # currently alive. With no expectations configured it simply surfaces every
+  # live process so the dashboard still shows something useful.
+  #
+  # Safe when Sidekiq is absent — every method degrades to empty results.
+  class ServerMonitor
+    DEAD_AFTER = 60 # seconds without a heartbeat => process considered gone
+    Status = Struct.new(:key, :name, :up, :processes, :last_beat_ago, keyword_init: true)
+    def self.statuses
+      new.statuses
+    end
+    def expected
+      ErrorRadar.config.expected_servers
+    end
+    def statuses
+      live = live_processes
+      if expected.empty?
+        return live.map do |p|
+          Status.new(
+            key: p[:identity],
+            name: "#{p[:hostname]} #{p[:tag]}".strip,
+            up: p[:beat_ago] && p[:beat_ago] <= DEAD_AFTER,
+            processes: [p],
+            last_beat_ago: p[:beat_ago]
+          )
+        end
+      end
+      expected.map do |exp|
+        matched = live.select { |p| matches?(p, exp) }
+        Status.new(
+          key: exp[:key],
+          name: exp[:name],
+          up: matched.any? { |p| p[:beat_ago] && p[:beat_ago] <= DEAD_AFTER },
+          processes: matched,
+          last_beat_ago: matched.map { |p| p[:beat_ago] }.compact.min
+        )
+      end
+    end
+    def unexpected_processes
+      return [] if expected.empty?
+      live_processes.reject { |p| expected.any? { |exp| matches?(p, exp) } }
+    end
+    def live_processes
+      return [] unless defined?(::Sidekiq)
+      require 'sidekiq/api'
+      now = Time.now.to_f
+      ::Sidekiq::ProcessSet.new.map do |p|
+        {
+          identity: p['identity'],
+          hostname: p['hostname'],
+          tag: p['tag'],
+          queues: Array(p['queues']),
+          concurrency: p['concurrency'],
+          busy: p['busy'],
+          rss: p['rss'],
+          quiet: p['quiet'] == 'true' || p['quiet'] == true,
+          started_at: p['started_at'] && Time.at(p['started_at']),
+          beat_ago: p['beat'] ? (now - p['beat']).round : nil
+        }
+      end
+    rescue StandardError => e
+      ErrorRadar::Tracking.warn_internal("ServerMonitor.live_processes failed: #{e.class}: #{e.message}")
+      []
+    end
+    private
+    def matches?(process, exp)
+      return true if present?(exp[:tag]) && process[:tag].to_s == exp[:tag]
+      return true if present?(exp[:host]) && process[:hostname].to_s.include?(exp[:host])
+      present?(exp[:queue_hint]) && process[:queues].include?(exp[:queue_hint]) &&
+        expected.none? { |o| o != exp && (process[:tag].to_s == o[:tag] || (present?(o[:host]) && process[:hostname].to_s.include?(o[:host].to_s))) }
+    end
+    def present?(value)
+      !value.nil? && value != ''
+    end
+  end
+end

data/lib/error_radar/tracking.rb ADDED Viewed

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+module ErrorRadar
+  # The capture facade. Auto-classifies common exception types, lets the host
+  # app plug in custom rules, then persists/rolls-up an ErrorLog. Never raises.
+  module Tracking
+    module_function
+    def capture(exception, source: nil, category: nil, severity: nil, context: {})
+      return nil unless ErrorRadar.config.enabled
+      category ||= categorize(exception)
+      severity ||= default_severity(exception, category)
+      attrs = {
+        category: category,
+        severity: severity,
+        error_class: exception.class.name,
+        source: source || infer_source(exception),
+        message: exception.message,
+        backtrace: Array(exception.backtrace).first(ErrorRadar.config.backtrace_lines),
+        context: context
+      }
+      ErrorRadar.config.detail_extractors.each do |extractor|
+        extra = safe_call(extractor, exception)
+        attrs.merge!(extra.compact) if extra.is_a?(Hash)
+      end
+      ErrorRadar::ErrorLog.record(**attrs)
+    rescue StandardError => e
+      warn_internal("capture failed: #{e.class}: #{e.message}")
+      nil
+    end
+    # Wrap a block (rake task, cron script, manual maintenance) so any exception
+    # is captured and then re-raised. Use at boundaries the web/Sidekiq handlers
+    # don't cover.
+    def monitor(source, category: nil, severity: nil, context: {})
+      yield
+    rescue StandardError => e
+      capture(e, source: source, category: category, severity: severity, context: context)
+      raise
+    end
+    # Log a problem without an exception object.
+    def notify(message, category: :application, severity: :error, source: nil, context: {})
+      return nil unless ErrorRadar.config.enabled
+      ErrorRadar::ErrorLog.record(category: category, severity: severity, message: message, source: source, context: context)
+    rescue StandardError => e
+      warn_internal("notify failed: #{e.class}: #{e.message}")
+      nil
+    end
+    def categorize(exception)
+      ErrorRadar.config.categorizers.each do |rule|
+        cat = safe_call(rule, exception)
+        return cat if cat
+      end
+      if defined?(ActiveRecord::ActiveRecordError) && exception.is_a?(ActiveRecord::ActiveRecordError)
+        :database
+      elsif exception.is_a?(SyntaxError) || exception.is_a?(NameError) ||
+            exception.is_a?(ArgumentError) || exception.is_a?(TypeError)
+        :syntax
+      elsif network_error?(exception)
+        :network
+      else
+        :application
+      end
+    end
+    def network_error?(exception)
+      names = %w[
+        Net::OpenTimeout Net::ReadTimeout Errno::ECONNREFUSED Errno::ECONNRESET
+        Errno::EHOSTUNREACH Errno::ETIMEDOUT SocketError Timeout::Error
+        OpenSSL::SSL::SSLError EOFError Faraday::ConnectionFailed Faraday::TimeoutError
+      ]
+      klass = exception.class
+      while klass
+        return true if names.include?(klass.name)
+        klass = klass.superclass
+      end
+      false
+    end
+    def default_severity(_exception, category)
+      case category.to_sym
+      when :syntax, :database then :critical
+      when :network, :external_api then :warning
+      else :error
+      end
+    end
+    def infer_source(exception)
+      line = Array(exception.backtrace).find { |l| l.include?('/app/') } || Array(exception.backtrace).first
+      return 'unknown' if line.nil? || line.empty?
+      line.split(':').first.to_s.split('/app/').last || line
+    end
+    def safe_call(callable, *args)
+      callable.call(*args)
+    rescue StandardError => e
+      warn_internal("custom rule failed: #{e.class}: #{e.message}")
+      nil
+    end
+    def warn_internal(message)
+      logger = defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : nil
+      logger ? logger.error("[ErrorRadar] #{message}") : warn("[ErrorRadar] #{message}")
+    end
+  end
+end

data/lib/error_radar/version.rb ADDED Viewed

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module ErrorRadar
+  VERSION = '0.1.0'
+end