error_radar 0.2.0 → 0.4.0

data/lib/error_radar/notifications/discord.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module ErrorRadar
+  module Notifications
+    module Discord
+      SEV_COLORS = {
+        'critical' => 0x7b001c,
+        'error'    => 0xdc3545,
+        'warning'  => 0xfd7e14,
+        'info'     => 0x17a2b8
+      }.freeze
+
+      def self.deliver(log)
+        url     = URI(ErrorRadar.config.discord_webhook_url)
+        payload = build_payload(log)
+
+        http              = Net::HTTP.new(url.host, url.port)
+        http.use_ssl      = url.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 5
+
+        req                 = Net::HTTP::Post.new(url)
+        req['Content-Type'] = 'application/json'
+        req.body            = payload.to_json
+
+        http.request(req)
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("Discord notification failed: #{e.message}")
+      end
+
+      def self.build_payload(log)
+        app    = ErrorRadar::Notifier.app_name
+        url    = ErrorRadar::Notifier.error_url(log)
+        prefix = log.new_fingerprint? ? '🆕 New error' : '🔁 Critical error'
+
+        fields = [
+          { name: 'Source',      value: (log.source || 'unknown').truncate(100), inline: true },
+          { name: 'Category',    value: log.category.to_s,                       inline: true },
+          { name: 'Severity',    value: log.severity.to_s,                       inline: true },
+          { name: 'Occurrences', value: log.occurrences.to_s,                    inline: true }
+        ]
+        fields << { name: 'View', value: "[Error Radar](#{url})", inline: false } if url
+
+        embed = {
+          title:       "#{prefix}: #{log.error_class}",
+          description: "```#{log.message.to_s.truncate(300)}```",
+          color:       SEV_COLORS[log.severity] || 0x6c757d,
+          fields:      fields,
+          footer:      { text: "[#{app}] Error Radar" },
+          timestamp:   log.last_seen_at&.iso8601
+        }.compact
+
+        { embeds: [embed] }
+      end
+    end
+  end
+end

data/lib/error_radar/notifications/email.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  module Notifications
+    # Delivers notification emails via ActionMailer (must be configured in
+    # the host app). Uses deliver_later so it doesn't block the request cycle.
+    module Email
+      def self.deliver(log)
+        return unless defined?(::ActionMailer::Base)
+
+        require 'error_radar/mailers/error_mailer'
+        ErrorRadar::ErrorMailer.new_error(log).deliver_later
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("Email notification failed: #{e.message}")
+      end
+    end
+  end
+end

data/lib/error_radar/notifications/slack.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module ErrorRadar
+  module Notifications
+    module Slack
+      SEV_EMOJI = {
+        'critical' => ':red_circle:',
+        'error'    => ':large_orange_circle:',
+        'warning'  => ':large_yellow_circle:',
+        'info'     => ':large_blue_circle:'
+      }.freeze
+
+      def self.deliver(log)
+        url     = URI(ErrorRadar.config.slack_webhook_url)
+        payload = build_payload(log)
+
+        http              = Net::HTTP.new(url.host, url.port)
+        http.use_ssl      = url.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 5
+
+        req                  = Net::HTTP::Post.new(url)
+        req['Content-Type']  = 'application/json'
+        req.body             = payload.to_json
+
+        http.request(req)
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("Slack notification failed: #{e.message}")
+      end
+
+      def self.build_payload(log)
+        emoji   = SEV_EMOJI[log.severity] || ':white_circle:'
+        title   = "#{emoji} #{log.new_fingerprint? ? 'New error' : 'Critical error'}: *#{log.error_class}*"
+        url     = ErrorRadar::Notifier.error_url(log)
+        app     = ErrorRadar::Notifier.app_name
+        channel = ErrorRadar.config.slack_channel
+
+        blocks = [
+          { type: 'section', text: { type: 'mrkdwn', text: "*[#{app}]* #{title}" } },
+          {
+            type: 'section',
+            fields: [
+              { type: 'mrkdwn', text: "*Source*\n#{(log.source || 'unknown').truncate(80)}" },
+              { type: 'mrkdwn', text: "*Category*\n#{log.category}" },
+              { type: 'mrkdwn', text: "*Severity*\n#{log.severity}" },
+              { type: 'mrkdwn', text: "*Occurrences*\n#{log.occurrences}" }
+            ]
+          },
+          {
+            type: 'section',
+            text: { type: 'mrkdwn', text: "*Message*\n```#{log.message.to_s.truncate(400)}```" }
+          }
+        ]
+
+        if url
+          blocks << {
+            type: 'actions',
+            elements: [{
+              type: 'button',
+              text: { type: 'plain_text', text: 'View in Error Radar', emoji: true },
+              url: url
+            }]
+          }
+        end
+
+        payload = { blocks: blocks, text: "[#{app}] #{log.error_class}: #{log.message.to_s.truncate(200)}" }
+        payload[:channel] = channel if channel.to_s != ''
+        payload
+      end
+    end
+  end
+end

data/lib/error_radar/notifications/webhook.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module ErrorRadar
+  module Notifications
+    # Generic outbound webhook. POSTs a JSON payload to any URL.
+    # Useful for PagerDuty, OpsGenie, custom scripts, etc.
+    module Webhook
+      def self.deliver(log, url:)
+        uri = URI(url)
+
+        http              = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = uri.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 5
+
+        req                 = Net::HTTP::Post.new(uri)
+        req['Content-Type'] = 'application/json'
+        req['User-Agent']   = "ErrorRadar/#{ErrorRadar::VERSION}"
+        req.body            = build_payload(log).to_json
+
+        http.request(req)
+      rescue StandardError => e
+        ErrorRadar::Tracking.warn_internal("Webhook (#{url}) notification failed: #{e.message}")
+      end
+
+      def self.build_payload(log)
+        {
+          event:         log.new_fingerprint? ? 'new_error' : 'recurring_error',
+          app:           ErrorRadar::Notifier.app_name,
+          error_class:   log.error_class,
+          source:        log.source,
+          category:      log.category,
+          severity:      log.severity,
+          message:       log.message.to_s.truncate(500),
+          occurrences:   log.occurrences,
+          fingerprint:   log.fingerprint,
+          first_seen_at: log.first_seen_at&.iso8601,
+          last_seen_at:  log.last_seen_at&.iso8601,
+          url:           ErrorRadar::Notifier.error_url(log)
+        }
+      end
+    end
+  end
+end

data/lib/error_radar/notifier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  # Dispatches alert notifications (Slack, Discord, email, webhooks, custom
+  # callbacks) after an ErrorLog is persisted. Called from Tracking.capture and
+  # Tracking.notify. Never raises — a broken notification must not affect the
+  # host application.
+  module Notifier
+    THROTTLE_MUTEX = Mutex.new
+    # fingerprint => Time of last notification (in-memory, resets on restart)
+    THROTTLE = {}
+    THROTTLE_INTERVAL = 3600 # seconds between repeat alerts per fingerprint
+
+    def self.dispatch(log)
+      return unless ErrorRadar.config.enabled
+      return unless should_fire?(log)
+
+      cfg = ErrorRadar.config
+      send_slack(log)                           if cfg.slack_webhook_url.to_s.start_with?('http')
+      send_discord(log)                         if cfg.discord_webhook_url.to_s.start_with?('http')
+      send_email(log)                           if cfg.email_recipients.any?
+      cfg.webhook_urls.each { |url| send_webhook(log, url) }
+      cfg.error_callbacks.each { |cb| safe_call(cb, log) }
+    rescue StandardError => e
+      ErrorRadar::Tracking.warn_internal("Notifier.dispatch failed: #{e.message}")
+    end
+
+    # ── Fire decision ──────────────────────────────────────────────────────
+    def self.should_fire?(log)
+      rules = Array(ErrorRadar.config.notify_on).map(&:to_sym)
+      return false if rules.empty?
+
+      # :new_error — fire exactly once per fingerprint (no throttle needed)
+      return true if rules.include?(:new_error) && log.new_fingerprint?
+
+      # :critical / :all — fire for recurring events, subject to throttle
+      matches_severity = rules.include?(:all) ||
+                         (rules.include?(:critical) && log.severity_critical?)
+      matches_severity && throttle_ok?(log.fingerprint)
+    end
+
+    def self.throttle_ok?(fingerprint)
+      THROTTLE_MUTEX.synchronize do
+        last = THROTTLE[fingerprint]
+        ok   = last.nil? || (Time.current - last) >= THROTTLE_INTERVAL
+        THROTTLE[fingerprint] = Time.current if ok
+        ok
+      end
+    end
+
+    # ── Channel dispatchers ────────────────────────────────────────────────
+    def self.send_slack(log)
+      require 'error_radar/notifications/slack'
+      Notifications::Slack.deliver(log)
+    end
+
+    def self.send_discord(log)
+      require 'error_radar/notifications/discord'
+      Notifications::Discord.deliver(log)
+    end
+
+    def self.send_email(log)
+      require 'error_radar/notifications/email'
+      Notifications::Email.deliver(log)
+    end
+
+    def self.send_webhook(log, url)
+      require 'error_radar/notifications/webhook'
+      Notifications::Webhook.deliver(log, url: url)
+    end
+
+    def self.safe_call(cb, log)
+      cb.call(log)
+    rescue StandardError => e
+      ErrorRadar::Tracking.warn_internal("on_error callback failed: #{e.message}")
+    end
+
+    # Build a deep-link URL to the error detail page.
+    def self.error_url(log)
+      host = ErrorRadar.config.app_host.to_s.chomp('/')
+      return nil if host.empty?
+
+      "#{host}/error_radar/errors/#{log.id}"
+    end
+
+    def self.app_name
+      ErrorRadar.config.app_name ||
+        (defined?(Rails) && Rails.application ? Rails.application.class.module_parent_name : 'App')
+    end
+  end
+end

data/lib/error_radar/tracking.rb

@@ -27,7 +27,9 @@ module ErrorRadar
         attrs.merge!(extra.compact) if extra.is_a?(Hash)
       end
 
-      ErrorRadar::ErrorLog.record(**attrs)
+      log = ErrorRadar::ErrorLog.record(**attrs)
+      ErrorRadar::Notifier.dispatch(log) if log
+      log
     rescue StandardError => e
       warn_internal("capture failed: #{e.class}: #{e.message}")
       nil
@@ -47,7 +49,9 @@ module ErrorRadar
     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)
+      log = ErrorRadar::ErrorLog.record(category: category, severity: severity, message: message, source: source, context: context)
+      ErrorRadar::Notifier.dispatch(log) if log
+      log
     rescue StandardError => e
       warn_internal("notify failed: #{e.class}: #{e.message}")
       nil

data/lib/error_radar/version.rb

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

data/lib/error_radar.rb

@@ -3,6 +3,7 @@
 require 'error_radar/version'
 require 'error_radar/configuration'
 require 'error_radar/tracking'
+require 'error_radar/notifier'
 require 'error_radar/middleware'
 require 'error_radar/server_monitor'
 require 'error_radar/engine'

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

@@ -8,9 +8,38 @@ ErrorRadar.configure do |config|
   config.enabled = !Rails.env.test?
 
   # --- Integrations (auto-detected; flip off if you don't want them) ---
-  config.install_middleware  = true   # Rack: capture web-layer exceptions
-  config.install_sidekiq     = true   # capture Sidekiq job failures (if Sidekiq present)
-  config.install_rails_admin = true   # register the ErrorLog board (if RailsAdmin present)
+  config.install_middleware  = true   # Rack: capture web-layer exceptions (auto)
+  config.install_sidekiq     = true   # capture Sidekiq job failures (auto, if Sidekiq present)
+  config.install_active_job  = true   # capture ActiveJob failures for any adapter (auto)
+  config.install_rake        = true   # capture Rake task failures (auto)
+  config.install_rails_admin = true   # register the ErrorLog board (auto, if RailsAdmin present)
+
+  # --- Notifications ---
+  # When to fire: :new_error (first occurrence of a fingerprint, default),
+  #               :critical  (any critical severity, throttled to 1/hour),
+  #               :all       (every occurrence, throttled to 1/hour per fingerprint)
+  config.notify_on = [:new_error]
+
+  # Slack incoming webhook (https://api.slack.com/messaging/webhooks)
+  # config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
+  # config.slack_channel     = '#errors'   # optional override
+
+  # Discord incoming webhook
+  # config.discord_webhook_url = ENV['DISCORD_WEBHOOK_URL']
+
+  # Email (requires ActionMailer to be configured in the host app)
+  # config.email_recipients = ['dev@myapp.com', 'oncall@myapp.com']
+  # config.email_from       = 'errors@myapp.com'
+
+  # Generic webhook — POST JSON to any URL (PagerDuty, OpsGenie, custom scripts)
+  # config.webhook_urls = [ENV['PAGERDUTY_WEBHOOK_URL']]
+
+  # Base URL used to generate deep-links in notifications
+  # config.app_host = 'https://myapp.com'
+  # config.app_name = 'MyApp'              # shown in notification title/subject
+
+  # Custom callback — runs after all built-in channels
+  # config.on_error { |error_log| MyPager.create_incident(error_log) }
 
   # --- Dashboard access control ---
   # Run as a before_action; raise/redirect inside to deny. Example with Devise:
@@ -45,10 +74,6 @@ ErrorRadar.configure do |config|
   # ]
 end
 
-# --- Optional: capture ActiveJob failures across ALL queue adapters ---
-# Add to app/jobs/application_job.rb (skip if you only use Sidekiq, since the
-# Sidekiq integration above already covers it):
-#
-#   class ApplicationJob < ActiveJob::Base
-#     include ErrorRadar::Integrations::ActiveJob
-#   end
+# ActiveJob is now captured automatically via install_active_job = true above.
+# No changes needed in ApplicationJob. Set install_active_job = false if you
+# only use Sidekiq and want to avoid double-counting.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: error_radar
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - chienbn9x
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -59,10 +59,16 @@ files:
 - Rakefile
 - app/controllers/error_radar/application_controller.rb
 - app/controllers/error_radar/dashboard_controller.rb
+- app/controllers/error_radar/errors_controller.rb
+- app/mailers/error_radar/error_mailer.rb
 - app/models/error_radar/application_record.rb
 - app/models/error_radar/error_log.rb
 - app/views/error_radar/dashboard/index.html.erb
 - app/views/error_radar/dashboard/show.html.erb
+- app/views/error_radar/error_mailer/new_error.html.erb
+- app/views/error_radar/error_mailer/new_error.text.erb
+- app/views/error_radar/errors/index.html.erb
+- app/views/error_radar/errors/show.html.erb
 - app/views/layouts/error_radar/application.html.erb
 - config/routes.rb
 - lib/error_radar.rb
@@ -70,8 +76,14 @@ files:
 - lib/error_radar/engine.rb
 - lib/error_radar/integrations/active_job.rb
 - lib/error_radar/integrations/rails_admin.rb
+- lib/error_radar/integrations/rake.rb
 - lib/error_radar/integrations/sidekiq.rb
 - lib/error_radar/middleware.rb
+- lib/error_radar/notifications/discord.rb
+- lib/error_radar/notifications/email.rb
+- lib/error_radar/notifications/slack.rb
+- lib/error_radar/notifications/webhook.rb
+- lib/error_radar/notifier.rb
 - lib/error_radar/server_monitor.rb
 - lib/error_radar/tracking.rb
 - lib/error_radar/version.rb