error_radar 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57b3fa6a7576ae08baeb699b180048363846c84ecbb489fc93e16ea537939898
-  data.tar.gz: 67008613bd52755dad89b7ed1abbc9a86eb92c138f95cae8005f5272e8336594
+  metadata.gz: 1522c6f867cba16786c499703bf76e18d8d7134109f8c925387a628fd0b7f420
+  data.tar.gz: f9bfc6fe5a5de9e8394b3c81a4b41913b82ed22e5f56ef72980936dc9ecc59f9
 SHA512:
-  metadata.gz: 2882f7be2a07a38bdafd4b44c8251774a470f37d44fcd3dc4403046cd2998eb1077ac576c97cd8aed6a43ab4a86153440598bafa5a6a47576f06bbc137a2528d
-  data.tar.gz: 8717757580e628dc988422df68c3a806bd7d9727f297439b5e7303cc049a48371f37035442dbfd12f7789cb8b480221b093720dda965f6ebeffc2c75ef3bcb57
+  metadata.gz: 13ae125f05a92939e320a4af5a55521c4f8bddde93fe702b44a2cc0919f2f47c754ed39f440787cb94040676e22d1efaa5a65195e306c955ca2be3cce70e4e8b
+  data.tar.gz: 782931704d0808b5c527a542ab2019b6f49726d9d8b7321ab63931c0788672edaa65eac04a5790f768a35c12296ae12233a38eb60dcfbb668c91535663c5e1cc

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.8.0] - 2026-07-03
+
+### Added
+- **Rate-based spike alerts**: add `:spike` to `config.notify_on` to fire a
+  notification when a single error exceeds `config.spike_threshold` (default: 10)
+  occurrences within `config.spike_window_minutes` (default: 5). Re-alerts once
+  per window after the first trigger.
+- **`ErrorRadar::SpikeDetector`**: detects spikes using two strategies — if
+  `track_occurrences` is enabled it queries `error_radar_occurrences` for an
+  exact cross-process count; otherwise falls back to an in-memory ring buffer
+  (per-process, resets on restart). Memory is capped at 1 000 timestamps per
+  fingerprint.
+- **`config.spike_threshold`** (default: 10) and **`config.spike_window_minutes`**
+  (default: 5) — tune the spike trigger.
+- **Spike throttle**: a spike alert re-fires at most once per window
+  (e.g. every 5 minutes), using a separate throttle key from `:critical`/`:all`.
+- **Event-aware notification channels**: all channels (Slack, Discord, email,
+  webhook) now receive the notification event (`:new_error`, `:spike`,
+  `:recurring`) and format accordingly:
+  - Slack: `:warning:` emoji, "danger" button colour, hit-count in title
+  - Discord: orange embed colour (`#ff6600`) for spikes
+  - Email subject: `[App] SPIKE ErrorClass: N hits in M min`
+  - Webhook payload: `event: "spike"` + `spike: { count:, window_minutes: }`
+
+### Changed
+- `Notifier.dispatch` now determines a single *event type* before dispatching,
+  preventing a log from matching both `:spike` and `:critical` simultaneously.
+- All channel `deliver` methods accept an optional `event` argument (default
+  `:recurring`) — backwards-compatible if called directly.
+
 ## [0.7.0] - 2026-07-03
 
 ### Added

data/app/mailers/error_radar/error_mailer.rb

@@ -4,14 +4,21 @@ module ErrorRadar
   class ErrorMailer < ActionMailer::Base
     layout false
 
-    def new_error(error_log)
-      @error    = error_log
-      @is_new   = error_log.new_fingerprint?
-      @url      = build_url
-      @app_name = ErrorRadar::Notifier.app_name
+    def new_error(error_log, event = :recurring)
+      @error      = error_log
+      @event      = event
+      @spike_data = error_log.instance_variable_get(:@spike_data)
+      @url        = build_url
+      @app_name   = ErrorRadar::Notifier.app_name
 
-      prefix  = @is_new ? 'New' : 'Critical'
-      subject = "[#{@app_name}] #{prefix} #{@error.severity}: #{@error.error_class}"
+      subject = case event
+                when :spike
+                  "[#{@app_name}] SPIKE #{@error.error_class}: #{@spike_data[:count]} hits in #{@spike_data[:window_minutes]} min"
+                when :new_error
+                  "[#{@app_name}] New #{@error.severity}: #{@error.error_class}"
+                else
+                  "[#{@app_name}] #{@error.severity.capitalize}: #{@error.error_class}"
+                end
 
       mail(
         to:      ErrorRadar.config.email_recipients,

data/lib/error_radar/configuration.rb

@@ -69,6 +69,13 @@ module ErrorRadar
       @error_callbacks << block
     end
 
+    # Spike detection ─────────────────────────────────────────────────────────
+    # Number of occurrences within spike_window_minutes that triggers a spike alert.
+    # Add :spike to notify_on to enable: config.notify_on = [:new_error, :spike]
+    attr_accessor :spike_threshold
+    # Rolling time window in minutes for counting occurrences.
+    attr_accessor :spike_window_minutes
+
     # Occurrences ─────────────────────────────────────────────────────────────
     # When true, each individual error hit is stored in error_radar_occurrences.
     # Requires running: bin/rails generate error_radar:upgrade_v060 && bin/rails db:migrate
@@ -156,6 +163,9 @@ module ErrorRadar
       @app_host             = nil
       @error_callbacks      = []
 
+      @spike_threshold     = 10
+      @spike_window_minutes = 5
+
       @track_occurrences        = false
       @max_occurrences_per_error = 200
 

data/lib/error_radar/notifications/discord.rb

@@ -13,10 +13,10 @@ module ErrorRadar
         'warning'  => 0xfd7e14,
         'info'     => 0x17a2b8
       }.freeze
+      SPIKE_COLOR = 0xff6600
 
-      def self.deliver(log)
-        url     = URI(ErrorRadar.config.discord_webhook_url)
-        payload = build_payload(log)
+      def self.deliver(log, event = :recurring)
+        url = URI(ErrorRadar.config.discord_webhook_url)
 
         http              = Net::HTTP.new(url.host, url.port)
         http.use_ssl      = url.scheme == 'https'
@@ -25,17 +25,26 @@ module ErrorRadar
 
         req                 = Net::HTTP::Post.new(url)
         req['Content-Type'] = 'application/json'
-        req.body            = payload.to_json
+        req.body            = build_payload(log, event).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'
+      def self.build_payload(log, event)
+        spike_data = log.instance_variable_get(:@spike_data)
+        app        = ErrorRadar::Notifier.app_name
+        link       = ErrorRadar::Notifier.error_url(log)
+
+        prefix, color = case event
+                        when :spike
+                          ["⚠️ Spike (#{spike_data[:count]} hits / #{spike_data[:window_minutes]} min)", SPIKE_COLOR]
+                        when :new_error
+                          ['🆕 New error', SEV_COLORS[log.severity] || 0x6c757d]
+                        else
+                          ['🔁 Recurring error', SEV_COLORS[log.severity] || 0x6c757d]
+                        end
 
         fields = [
           { name: 'Source',      value: (log.source || 'unknown').truncate(100), inline: true },
@@ -43,12 +52,12 @@ module ErrorRadar
           { 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
+        fields << { name: 'View', value: "[Error Radar](#{link})", inline: false } if link
 
         embed = {
           title:       "#{prefix}: #{log.error_class}",
           description: "```#{log.message.to_s.truncate(300)}```",
-          color:       SEV_COLORS[log.severity] || 0x6c757d,
+          color:       color,
           fields:      fields,
           footer:      { text: "[#{app}] Error Radar" },
           timestamp:   log.last_seen_at&.iso8601

data/lib/error_radar/notifications/email.rb

@@ -5,11 +5,11 @@ module ErrorRadar
     # 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)
+      def self.deliver(log, event = :recurring)
         return unless defined?(::ActionMailer::Base)
 
         require 'error_radar/mailers/error_mailer'
-        ErrorRadar::ErrorMailer.new_error(log).deliver_later
+        ErrorRadar::ErrorMailer.new_error(log, event).deliver_later
       rescue StandardError => e
         ErrorRadar::Tracking.warn_internal("Email notification failed: #{e.message}")
       end

data/lib/error_radar/notifications/slack.rb

@@ -14,40 +14,47 @@ module ErrorRadar
         'info'     => ':large_blue_circle:'
       }.freeze
 
-      def self.deliver(log)
-        url     = URI(ErrorRadar.config.slack_webhook_url)
-        payload = build_payload(log)
+      def self.deliver(log, event = :recurring)
+        url = URI(ErrorRadar.config.slack_webhook_url)
 
         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
+        req                 = Net::HTTP::Post.new(url)
+        req['Content-Type'] = 'application/json'
+        req.body            = build_payload(log, event).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
+      def self.build_payload(log, event)
+        spike_data = log.instance_variable_get(:@spike_data)
+        app        = ErrorRadar::Notifier.app_name
+        link       = ErrorRadar::Notifier.error_url(log)
+        channel    = ErrorRadar.config.slack_channel
+
+        emoji, title = case event
+                       when :spike
+                         [':warning:', "Spike — #{spike_data[:count]} hits in #{spike_data[:window_minutes]} min: *#{log.error_class}*"]
+                       when :new_error
+                         [SEV_EMOJI[log.severity] || ':white_circle:', "New error: *#{log.error_class}*"]
+                       else
+                         [SEV_EMOJI[log.severity] || ':white_circle:', "#{log.severity.capitalize} error: *#{log.error_class}*"]
+                       end
 
         blocks = [
-          { type: 'section', text: { type: 'mrkdwn', text: "*[#{app}]* #{title}" } },
+          { type: 'section', text: { type: 'mrkdwn', text: "#{emoji} *[#{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: 'mrkdwn', text: "*Total occurrences*\n#{log.occurrences}" }
             ]
           },
           {
@@ -56,13 +63,14 @@ module ErrorRadar
           }
         ]
 
-        if url
+        if link
           blocks << {
             type: 'actions',
             elements: [{
               type: 'button',
-              text: { type: 'plain_text', text: 'View in Error Radar', emoji: true },
-              url: url
+              text:  { type: 'plain_text', text: 'View in Error Radar', emoji: true },
+              url:   link,
+              style: event == :spike ? 'danger' : 'primary'
             }]
           }
         end

data/lib/error_radar/notifications/webhook.rb

@@ -9,7 +9,7 @@ module ErrorRadar
     # Generic outbound webhook. POSTs a JSON payload to any URL.
     # Useful for PagerDuty, OpsGenie, custom scripts, etc.
     module Webhook
-      def self.deliver(log, url:)
+      def self.deliver(log, url:, event: :recurring)
         uri = URI(url)
 
         http              = Net::HTTP.new(uri.host, uri.port)
@@ -20,16 +20,18 @@ module ErrorRadar
         req                 = Net::HTTP::Post.new(uri)
         req['Content-Type'] = 'application/json'
         req['User-Agent']   = "ErrorRadar/#{ErrorRadar::VERSION}"
-        req.body            = build_payload(log).to_json
+        req.body            = build_payload(log, event).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',
+      def self.build_payload(log, event)
+        spike_data = log.instance_variable_get(:@spike_data)
+
+        payload = {
+          event:         event.to_s,
           app:           ErrorRadar::Notifier.app_name,
           error_class:   log.error_class,
           source:        log.source,
@@ -42,6 +44,15 @@ module ErrorRadar
           last_seen_at:  log.last_seen_at&.iso8601,
           url:           ErrorRadar::Notifier.error_url(log)
         }
+
+        if spike_data
+          payload[:spike] = {
+            count:          spike_data[:count],
+            window_minutes: spike_data[:window_minutes]
+          }
+        end
+
+        payload
       end
     end
   end

data/lib/error_radar/notifier.rb

@@ -5,68 +5,105 @@ module ErrorRadar
   # callbacks) after an ErrorLog is persisted. Called from Tracking.capture and
   # Tracking.notify. Never raises — a broken notification must not affect the
   # host application.
+  #
+  # Notification events:
+  #   :new_error  — first time a fingerprint is seen (no throttle)
+  #   :spike      — error rate exceeds config.spike_threshold in the window
+  #   :recurring  — matches :critical or :all rule, throttled to 1/hour
   module Notifier
-    THROTTLE_MUTEX = Mutex.new
-    # fingerprint => Time of last notification (in-memory, resets on restart)
-    THROTTLE = {}
+    THROTTLE_MUTEX    = Mutex.new
+    # key => Time of last notification (in-memory, resets on restart)
+    # Keys: fingerprint (for :recurring) or "spike:fingerprint" (for :spike)
+    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) }
+      rules = Array(ErrorRadar.config.notify_on).map(&:to_sym)
+      return if rules.empty?
+
+      # Record the hit for in-memory spike tracking before we test the count.
+      if rules.include?(:spike)
+        require 'error_radar/spike_detector'
+        SpikeDetector.record_hit(log.fingerprint)
+      end
+
+      event = determine_event(log, rules)
+      return unless event
+
+      fire_all(log, event)
     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?
+    def self.determine_event(log, rules)
+      # :new_error fires exactly once per fingerprint, no throttle
+      return :new_error 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)
+      # :spike — rate-based alert when occurrences in window exceed threshold
+      if rules.include?(:spike)
+        spike_count = SpikeDetector.check(log)
+        if spike_count
+          window_secs = ErrorRadar.config.spike_window_minutes * 60
+          if throttle_ok?("spike:#{log.fingerprint}", window_secs)
+            log.instance_variable_set(:@spike_data, {
+              count:          spike_count,
+              window_minutes: ErrorRadar.config.spike_window_minutes
+            })
+            return :spike
+          end
+        end
+      end
+
+      # :critical / :all — throttled recurring alerts
+      matches = rules.include?(:all) ||
+                (rules.include?(:critical) && log.severity_critical?)
+      return :recurring if matches && throttle_ok?(log.fingerprint, THROTTLE_INTERVAL)
+
+      nil
     end
 
-    def self.throttle_ok?(fingerprint)
+    def self.throttle_ok?(key, interval = THROTTLE_INTERVAL)
       THROTTLE_MUTEX.synchronize do
-        last = THROTTLE[fingerprint]
-        ok   = last.nil? || (Time.current - last) >= THROTTLE_INTERVAL
-        THROTTLE[fingerprint] = Time.current if ok
+        last = THROTTLE[key]
+        ok   = last.nil? || (Time.current - last) >= interval
+        THROTTLE[key] = Time.current if ok
         ok
       end
     end
 
     # ── Channel dispatchers ────────────────────────────────────────────────
-    def self.send_slack(log)
+
+    def self.fire_all(log, event)
+      cfg = ErrorRadar.config
+      send_slack(log, event)                     if cfg.slack_webhook_url.to_s.start_with?('http')
+      send_discord(log, event)                   if cfg.discord_webhook_url.to_s.start_with?('http')
+      send_email(log, event)                     if cfg.email_recipients.any?
+      cfg.webhook_urls.each { |url| send_webhook(log, url, event) }
+      cfg.error_callbacks.each { |cb| safe_call(cb, log) }
+    end
+
+    def self.send_slack(log, event)
       require 'error_radar/notifications/slack'
-      Notifications::Slack.deliver(log)
+      Notifications::Slack.deliver(log, event)
     end
 
-    def self.send_discord(log)
+    def self.send_discord(log, event)
       require 'error_radar/notifications/discord'
-      Notifications::Discord.deliver(log)
+      Notifications::Discord.deliver(log, event)
     end
 
-    def self.send_email(log)
+    def self.send_email(log, event)
       require 'error_radar/notifications/email'
-      Notifications::Email.deliver(log)
+      Notifications::Email.deliver(log, event)
     end
 
-    def self.send_webhook(log, url)
+    def self.send_webhook(log, url, event)
       require 'error_radar/notifications/webhook'
-      Notifications::Webhook.deliver(log, url: url)
+      Notifications::Webhook.deliver(log, url: url, event: event)
     end
 
     def self.safe_call(cb, log)
@@ -75,7 +112,8 @@ module ErrorRadar
       ErrorRadar::Tracking.warn_internal("on_error callback failed: #{e.message}")
     end
 
-    # Build a deep-link URL to the error detail page.
+    # ── Helpers ───────────────────────────────────────────────────────────
+
     def self.error_url(log)
       host = ErrorRadar.config.app_host.to_s.chomp('/')
       return nil if host.empty?

data/lib/error_radar/spike_detector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ErrorRadar
+  # Detects sudden error-rate spikes for a given fingerprint.
+  #
+  # Strategy (in order of preference):
+  #   1. If track_occurrences is on — query error_radar_occurrences for exact
+  #      count in the window. Accurate across processes and survives restarts.
+  #   2. In-memory ring buffer per fingerprint. Fast, zero extra DB queries, but
+  #      resets on process restart and is per-worker (not shared across Puma workers).
+  module SpikeDetector
+    MUTEX = Mutex.new
+    # fingerprint => Array<Time> of recent hit timestamps (in-memory fallback)
+    HITS = Hash.new { |h, k| h[k] = [] }
+    # Cap per-key buffer to avoid unbounded growth on very high-volume errors
+    MAX_HITS_PER_KEY = 1000
+
+    # Record a hit in the in-memory ring buffer.
+    # Called by Notifier before spike detection so the current hit is counted.
+    def self.record_hit(fingerprint)
+      MUTEX.synchronize do
+        arr = HITS[fingerprint]
+        arr << Time.current
+        arr.shift while arr.size > MAX_HITS_PER_KEY
+      end
+    end
+
+    # Returns the number of recent hits if >= config threshold, false otherwise.
+    def self.check(log)
+      threshold = ErrorRadar.config.spike_threshold.to_i
+      window    = ErrorRadar.config.spike_window_minutes.to_i
+      return false unless threshold > 0 && window > 0
+
+      count = recent_count(log, window)
+      count >= threshold ? count : false
+    end
+
+    class << self
+      private
+
+      def recent_count(log, window_minutes)
+        if ErrorRadar.config.track_occurrences && defined?(ErrorRadar::ErrorOccurrence)
+          begin
+            return ErrorRadar::ErrorOccurrence
+                     .where(error_log_id: log.id)
+                     .where('occurred_at >= ?', window_minutes.minutes.ago)
+                     .count
+          rescue ActiveRecord::StatementInvalid
+            # Table not yet created — fall through to in-memory
+          end
+        end
+
+        cutoff = window_minutes.minutes.ago
+        MUTEX.synchronize do
+          (HITS[log.fingerprint] || []).count { |t| t >= cutoff }
+        end
+      end
+    end
+  end
+end

data/lib/error_radar/version.rb

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

data/lib/error_radar.rb

@@ -5,6 +5,7 @@ require 'error_radar/configuration'
 require 'error_radar/tracking'
 require 'error_radar/notifier'
 require 'error_radar/cleanup'
+require 'error_radar/spike_detector'
 require 'error_radar/middleware'
 require 'error_radar/server_monitor'
 require 'error_radar/engine'

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

@@ -15,10 +15,19 @@ ErrorRadar.configure do |config|
   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)
+  # When to fire:
+  #   :new_error  — first occurrence of a fingerprint (default, no throttle)
+  #   :critical   — any critical-severity occurrence, throttled to 1/hour
+  #   :all        — every occurrence, throttled to 1/hour per fingerprint
+  #   :spike      — rate spike: N hits in M minutes (configure below)
   config.notify_on = [:new_error]
+  # config.notify_on = [:new_error, :spike]
+
+  # --- Spike detection (requires :spike in notify_on) ---
+  # Fire an alert when a single error hits >= spike_threshold times within
+  # spike_window_minutes. Re-alerts once per window after that.
+  # config.spike_threshold      = 10   # occurrences …
+  # config.spike_window_minutes = 5    # … in this many minutes
 
   # Slack incoming webhook (https://api.slack.com/messaging/webhooks)
   # config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: error_radar
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - chienbn9x
@@ -92,6 +92,7 @@ files:
 - lib/error_radar/notifications/webhook.rb
 - lib/error_radar/notifier.rb
 - lib/error_radar/server_monitor.rb
+- lib/error_radar/spike_detector.rb
 - lib/error_radar/tracking.rb
 - lib/error_radar/version.rb
 - lib/generators/error_radar/install/install_generator.rb