findbug 0.2.0

data/lib/findbug/alerts/channels/discord.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Findbug
+  module Alerts
+    module Channels
+      # Discord sends alerts via Discord webhooks.
+      #
+      # CONFIGURATION
+      # =============
+      #
+      #   config.alerts do |alerts|
+      #     alerts.discord(
+      #       enabled: true,
+      #       webhook_url: ENV["DISCORD_WEBHOOK_URL"],
+      #       username: "Findbug",  # optional
+      #       avatar_url: "https://..." # optional
+      #     )
+      #   end
+      #
+      # SETTING UP DISCORD WEBHOOK
+      # ==========================
+      #
+      # 1. Go to your Discord server settings
+      # 2. Navigate to Integrations > Webhooks
+      # 3. Create a new webhook
+      # 4. Copy the webhook URL
+      #
+      # Discord webhooks are similar to Slack but use a different payload format.
+      #
+      class Discord < Base
+        def send_alert(error_event)
+          webhook_url = config[:webhook_url]
+          return if webhook_url.blank?
+
+          payload = build_payload(error_event)
+          post_to_webhook(webhook_url, payload)
+        end
+
+        private
+
+        def build_payload(error_event)
+          {
+            username: config[:username] || "Findbug",
+            avatar_url: config[:avatar_url],
+            embeds: [build_embed(error_event)]
+          }.compact
+        end
+
+        def build_embed(error_event)
+          embed = {
+            title: error_event.exception_class.truncate(256),
+            description: error_event.message.to_s.truncate(2048),
+            color: severity_color_decimal(error_event.severity),
+            url: error_url(error_event),
+            fields: build_fields(error_event),
+            footer: {
+              text: "Findbug | #{error_event.environment}"
+            },
+            timestamp: error_event.last_seen_at.iso8601
+          }
+
+          embed.compact
+        end
+
+        def build_fields(error_event)
+          fields = []
+
+          fields << {
+            name: "Severity",
+            value: error_event.severity.upcase,
+            inline: true
+          }
+
+          fields << {
+            name: "Occurrences",
+            value: error_event.occurrence_count.to_s,
+            inline: true
+          }
+
+          if error_event.release_version
+            fields << {
+              name: "Release",
+              value: error_event.release_version.to_s.truncate(100),
+              inline: true
+            }
+          end
+
+          # Add backtrace (limited to Discord field limits)
+          if error_event.backtrace_lines.any?
+            backtrace = error_event.backtrace_lines.first(5).join("\n")
+            fields << {
+              name: "Backtrace",
+              value: "```\n#{backtrace.truncate(1000)}\n```",
+              inline: false
+            }
+          end
+
+          # Add user info
+          if error_event.user
+            user_info = [
+              error_event.user["email"],
+              error_event.user["id"] ? "ID: #{error_event.user['id']}" : nil
+            ].compact.join("\n")
+
+            fields << {
+              name: "User",
+              value: user_info,
+              inline: false
+            } if user_info.present?
+          end
+
+          fields
+        end
+
+        # Discord uses decimal color values
+        def severity_color_decimal(severity)
+          case severity
+          when "error" then 14_423_100   # #dc3545 in decimal
+          when "warning" then 16_761_095 # #ffc107
+          when "info" then 1_548_984     # #17a2b8
+          else 7_107_965                 # #6c757d
+          end
+        end
+
+        def post_to_webhook(webhook_url, payload)
+          uri = URI.parse(webhook_url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+          http.open_timeout = 5
+          http.read_timeout = 5
+
+          request = Net::HTTP::Post.new(uri.path)
+          request["Content-Type"] = "application/json"
+          request.body = payload.to_json
+
+          response = http.request(request)
+
+          # Discord returns 204 No Content on success
+          unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPNoContent)
+            Findbug.logger.error(
+              "[Findbug] Discord webhook failed: #{response.code} #{response.body}"
+            )
+          end
+        rescue StandardError => e
+          Findbug.logger.error("[Findbug] Discord alert failed: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/findbug/alerts/channels/email.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Findbug
+  module Alerts
+    module Channels
+      # Email sends alert emails via ActionMailer.
+      #
+      # CONFIGURATION
+      # =============
+      #
+      #   config.alerts do |alerts|
+      #     alerts.email(
+      #       enabled: true,
+      #       recipients: ["dev-team@example.com", "oncall@example.com"],
+      #       from: "findbug@example.com"  # optional
+      #     )
+      #   end
+      #
+      # REQUIREMENTS
+      # ============
+      #
+      # ActionMailer must be configured in your Rails app.
+      # The gem doesn't configure SMTP - it uses your app's mailer config.
+      #
+      class Email < Base
+        def send_alert(error_event)
+          recipients = config[:recipients]
+          return if recipients.blank?
+
+          # Use ActionMailer if available
+          if defined?(ActionMailer::Base)
+            FindbugMailer.error_alert(error_event, recipients).deliver_later
+          else
+            Findbug.logger.warn("[Findbug] ActionMailer not available for email alerts")
+          end
+        end
+      end
+
+      # Simple mailer for error alerts
+      #
+      # We define this inline because it's simple and self-contained.
+      # Users can override by creating their own FindbugMailer.
+      #
+      class FindbugMailer < ActionMailer::Base
+        default from: -> { Findbug.config.alerts.channel(:email)&.dig(:from) || "findbug@localhost" }
+
+        def error_alert(error_event, recipients)
+          @error = error_event
+          @error_url = build_error_url(error_event)
+
+          subject = "[#{Rails.env}] #{error_event.exception_class}: #{error_event.message.to_s.truncate(50)}"
+
+          mail(
+            to: recipients,
+            subject: subject
+          ) do |format|
+            format.text { render plain: build_text_body(error_event) }
+            format.html { render html: build_html_body(error_event).html_safe }
+          end
+        end
+
+        private
+
+        def build_text_body(error_event)
+          <<~TEXT
+            ERROR ALERT
+            ===========
+
+            Exception: #{error_event.exception_class}
+            Message: #{error_event.message}
+            Severity: #{error_event.severity.upcase}
+            Environment: #{error_event.environment}
+
+            Occurrences: #{error_event.occurrence_count}
+            First seen: #{error_event.first_seen_at}
+            Last seen: #{error_event.last_seen_at}
+
+            #{@error_url ? "View in dashboard: #{@error_url}" : ""}
+
+            BACKTRACE
+            ---------
+            #{error_event.backtrace_lines.first(10).join("\n")}
+
+            CONTEXT
+            -------
+            #{format_context(error_event)}
+          TEXT
+        end
+
+        def build_html_body(error_event)
+          <<~HTML
+            <!DOCTYPE html>
+            <html>
+            <head>
+              <style>
+                body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+                .container { max-width: 600px; margin: 0 auto; background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+                .header { background: #dc3545; color: white; padding: 20px; }
+                .header h1 { margin: 0; font-size: 18px; }
+                .content { padding: 20px; }
+                .meta { color: #666; font-size: 14px; margin-bottom: 20px; }
+                .section { margin-bottom: 20px; }
+                .section h3 { margin: 0 0 10px 0; font-size: 14px; color: #333; border-bottom: 1px solid #eee; padding-bottom: 5px; }
+                .backtrace { background: #f8f9fa; padding: 10px; font-family: monospace; font-size: 12px; overflow-x: auto; border-radius: 4px; }
+                .btn { display: inline-block; padding: 10px 20px; background: #007bff; color: white; text-decoration: none; border-radius: 4px; }
+                code { background: #f0f0f0; padding: 2px 6px; border-radius: 3px; font-size: 13px; }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <div class="header">
+                  <h1>#{error_event.exception_class}</h1>
+                </div>
+                <div class="content">
+                  <p><strong>#{h(error_event.message)}</strong></p>
+
+                  <div class="meta">
+                    <span>#{error_event.severity.upcase}</span> &bull;
+                    <span>#{error_event.environment}</span> &bull;
+                    <span>#{error_event.occurrence_count} occurrence(s)</span>
+                  </div>
+
+                  #{@error_url ? "<p><a href=\"#{@error_url}\" class=\"btn\">View in Dashboard</a></p>" : ""}
+
+                  <div class="section">
+                    <h3>Backtrace</h3>
+                    <div class="backtrace">#{error_event.backtrace_lines.first(10).map { |l| h(l) }.join("<br>")}</div>
+                  </div>
+
+                  <div class="section">
+                    <h3>Request Info</h3>
+                    #{format_request_html(error_event)}
+                  </div>
+                </div>
+              </div>
+            </body>
+            </html>
+          HTML
+        end
+
+        def format_context(error_event)
+          request = error_event.request
+          return "No request context" unless request
+
+          [
+            "Method: #{request['method']}",
+            "Path: #{request['path']}",
+            "IP: #{request['ip']}",
+            "User Agent: #{request['user_agent']}"
+          ].join("\n")
+        end
+
+        def format_request_html(error_event)
+          request = error_event.request
+          return "<p>No request context</p>" unless request
+
+          <<~HTML
+            <p>
+              <code>#{request['method']}</code> #{h(request['path'])}<br>
+              IP: #{request['ip']}<br>
+              User Agent: #{h(request['user_agent'].to_s.truncate(100))}
+            </p>
+          HTML
+        end
+
+        def build_error_url(error_event)
+          base_url = ENV.fetch("FINDBUG_BASE_URL", nil)
+          return nil unless base_url
+
+          "#{base_url}#{Findbug.config.web_path}/errors/#{error_event.id}"
+        end
+
+        def h(text)
+          ERB::Util.html_escape(text)
+        end
+      end
+    end
+  end
+end

data/lib/findbug/alerts/channels/slack.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Findbug
+  module Alerts
+    module Channels
+      # Slack sends alerts via Slack incoming webhooks.
+      #
+      # CONFIGURATION
+      # =============
+      #
+      #   config.alerts do |alerts|
+      #     alerts.slack(
+      #       enabled: true,
+      #       webhook_url: ENV["SLACK_WEBHOOK_URL"],
+      #       channel: "#errors",  # optional, overrides webhook default
+      #       username: "Findbug", # optional
+      #       icon_emoji: ":bug:"  # optional
+      #     )
+      #   end
+      #
+      # SETTING UP SLACK WEBHOOK
+      # ========================
+      #
+      # 1. Go to https://api.slack.com/apps
+      # 2. Create a new app (or use existing)
+      # 3. Add "Incoming Webhooks" feature
+      # 4. Create a webhook for your channel
+      # 5. Copy the webhook URL
+      #
+      class Slack < Base
+        def send_alert(error_event)
+          webhook_url = config[:webhook_url]
+          return if webhook_url.blank?
+
+          payload = build_payload(error_event)
+          post_to_webhook(webhook_url, payload)
+        end
+
+        private
+
+        def build_payload(error_event)
+          {
+            channel: config[:channel],
+            username: config[:username] || "Findbug",
+            icon_emoji: config[:icon_emoji] || ":bug:",
+            attachments: [build_attachment(error_event)]
+          }.compact
+        end
+
+        def build_attachment(error_event)
+          {
+            color: severity_color(error_event.severity),
+            title: "#{error_event.exception_class}",
+            title_link: error_url(error_event),
+            text: error_event.message.to_s.truncate(500),
+            fields: build_fields(error_event),
+            footer: "Findbug | #{error_event.environment}",
+            ts: error_event.last_seen_at.to_i
+          }.compact
+        end
+
+        def build_fields(error_event)
+          fields = []
+
+          fields << {
+            title: "Occurrences",
+            value: error_event.occurrence_count.to_s,
+            short: true
+          }
+
+          fields << {
+            title: "Severity",
+            value: error_event.severity.upcase,
+            short: true
+          }
+
+          if error_event.release_version
+            fields << {
+              title: "Release",
+              value: error_event.release_version.to_s.truncate(20),
+              short: true
+            }
+          end
+
+          # Add first backtrace line
+          if error_event.backtrace_lines.any?
+            fields << {
+              title: "Location",
+              value: "`#{error_event.backtrace_lines.first.truncate(80)}`",
+              short: false
+            }
+          end
+
+          # Add user info if present
+          if error_event.user
+            user_info = [
+              error_event.user["email"],
+              error_event.user["id"] ? "ID: #{error_event.user['id']}" : nil
+            ].compact.join(" | ")
+
+            fields << {
+              title: "User",
+              value: user_info,
+              short: false
+            } if user_info.present?
+          end
+
+          fields
+        end
+
+        def severity_color(severity)
+          case severity
+          when "error" then "#dc3545"   # Red
+          when "warning" then "#ffc107" # Yellow
+          when "info" then "#17a2b8"    # Blue
+          else "#6c757d"                # Gray
+          end
+        end
+
+        def post_to_webhook(webhook_url, payload)
+          uri = URI.parse(webhook_url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+          http.open_timeout = 5
+          http.read_timeout = 5
+
+          request = Net::HTTP::Post.new(uri.path)
+          request["Content-Type"] = "application/json"
+          request.body = payload.to_json
+
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            Findbug.logger.error(
+              "[Findbug] Slack webhook failed: #{response.code} #{response.body}"
+            )
+          end
+        rescue StandardError => e
+          Findbug.logger.error("[Findbug] Slack alert failed: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/findbug/alerts/channels/webhook.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Findbug
+  module Alerts
+    module Channels
+      # Webhook sends alerts to a generic HTTP endpoint.
+      #
+      # CONFIGURATION
+      # =============
+      #
+      #   config.alerts do |alerts|
+      #     alerts.webhook(
+      #       enabled: true,
+      #       url: "https://your-service.com/findbug-webhook",
+      #       headers: {
+      #         "Authorization" => "Bearer #{ENV['WEBHOOK_TOKEN']}",
+      #         "X-Custom-Header" => "value"
+      #       },
+      #       method: "POST"  # optional, defaults to POST
+      #     )
+      #   end
+      #
+      # PAYLOAD FORMAT
+      # ==============
+      #
+      # The webhook receives a JSON payload with the full error event:
+      #
+      #   {
+      #     "event_type": "error",
+      #     "error": {
+      #       "id": 123,
+      #       "exception_class": "NoMethodError",
+      #       "message": "undefined method...",
+      #       "severity": "error",
+      #       "occurrence_count": 5,
+      #       "first_seen_at": "2024-01-01T00:00:00Z",
+      #       "last_seen_at": "2024-01-01T01:00:00Z",
+      #       "environment": "production",
+      #       "release": "abc123",
+      #       "backtrace": [...],
+      #       "context": {...}
+      #     }
+      #   }
+      #
+      # USE CASES
+      # =========
+      #
+      # - Custom alerting systems
+      # - Integration with internal tools
+      # - PagerDuty/OpsGenie (if no native integration)
+      # - Log aggregation services
+      # - Custom notification services
+      #
+      class Webhook < Base
+        def send_alert(error_event)
+          url = config[:url]
+          return if url.blank?
+
+          payload = build_payload(error_event)
+          post_to_webhook(url, payload)
+        end
+
+        private
+
+        def build_payload(error_event)
+          {
+            event_type: "error",
+            timestamp: Time.now.utc.iso8601,
+            findbug_version: Findbug::VERSION,
+            error: {
+              id: error_event.id,
+              fingerprint: error_event.fingerprint,
+              exception_class: error_event.exception_class,
+              message: error_event.message,
+              severity: error_event.severity,
+              status: error_event.status,
+              handled: error_event.handled,
+              occurrence_count: error_event.occurrence_count,
+              first_seen_at: error_event.first_seen_at&.iso8601,
+              last_seen_at: error_event.last_seen_at&.iso8601,
+              environment: error_event.environment,
+              release: error_event.release_version,
+              backtrace: error_event.backtrace_lines,
+              context: error_event.context,
+              user: error_event.user,
+              request: error_event.request,
+              tags: error_event.tags,
+              url: error_url(error_event)
+            }
+          }
+        end
+
+        def post_to_webhook(url, payload)
+          uri = URI.parse(url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+          http.open_timeout = 5
+          http.read_timeout = 10
+
+          method = config[:method]&.upcase || "POST"
+          request = build_request(method, uri, payload)
+
+          # Add custom headers
+          (config[:headers] || {}).each do |key, value|
+            request[key] = value
+          end
+
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            Findbug.logger.error(
+              "[Findbug] Webhook failed: #{response.code} #{response.body.to_s.truncate(200)}"
+            )
+          end
+        rescue StandardError => e
+          Findbug.logger.error("[Findbug] Webhook alert failed: #{e.message}")
+        end
+
+        def build_request(method, uri, payload)
+          case method
+          when "POST"
+            request = Net::HTTP::Post.new(uri.request_uri)
+            request["Content-Type"] = "application/json"
+            request.body = payload.to_json
+            request
+          when "PUT"
+            request = Net::HTTP::Put.new(uri.request_uri)
+            request["Content-Type"] = "application/json"
+            request.body = payload.to_json
+            request
+          else
+            raise ArgumentError, "Unsupported HTTP method: #{method}"
+          end
+        end
+      end
+    end
+  end
+end