newshound 0.1.1 → 0.2.1

data/lib/newshound/exception_reporter.rb

@@ -24,6 +24,14 @@ module Newshound
         *format_exceptions
       ]
     end
+    alias_method :report, :generate_report
+
+    # Returns data formatted for the banner UI
+    def banner_data
+      {
+        exceptions: recent_exceptions.map { |exception| format_exception_for_banner(exception) }
+      }
+    end
 
     private
 
@@ -53,29 +61,100 @@ module Newshound
     end
 
     def format_exception_text(exception, number)
+      details = parse_exception_details(exception)
+
       <<~TEXT
-        *#{number}. #{exception.title || exception.exception_class}*
+        *#{number}. #{exception_title(exception)}*
         • *Time:* #{exception.created_at.strftime('%I:%M %p')}
-        • *Controller:* #{exception.controller_name}##{exception.action_name}
-        • *Count:* #{exception_count(exception)}
-        #{format_message(exception)}
+        #{format_controller(details)}
+        #{format_message(exception, details)}
       TEXT
     end
 
-    def format_message(exception)
-      return "" unless exception.message.present?
-      
-      message = exception.message.truncate(100)
+    def exception_title(exception)
+      if exception.respond_to?(:title) && exception.title.present?
+        exception.title
+      elsif exception.respond_to?(:exception_class) && exception.exception_class.present?
+        exception.exception_class
+      else
+        "Unknown Exception"
+      end
+    end
+
+    def parse_exception_details(exception)
+      return {} unless exception.respond_to?(:body) && exception.body.present?
+
+      JSON.parse(exception.body)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def format_controller(details)
+      return String.new unless details["controller_name"] && details["action_name"]
+
+      "• *Controller:* #{details['controller_name']}##{details['action_name']}\n"
+    end
+
+    def format_message(exception, details = nil)
+      details ||= parse_exception_details(exception)
+
+      # Try to get message from different sources
+      message = if details["message"].present?
+        details["message"]
+      elsif exception.respond_to?(:message) && exception.message.present?
+        exception.message
+      end
+
+      return String.new unless message.present?
+
+      message = message.to_s.truncate(100)
       "• *Message:* `#{message}`"
     end
 
     def exception_count(exception)
       return 0 unless exception_source
 
-      exception_source
-        .where(exception_class: exception.exception_class)
-        .where("created_at >= ?", time_range.ago)
-        .count
+      # Use title for exception-track, exception_class for other systems
+      if exception.respond_to?(:title) && exception.title.present?
+        exception_source
+          .where(title: exception.title)
+          .where("created_at >= ?", time_range.ago)
+          .count
+      elsif exception.respond_to?(:exception_class)
+        exception_source
+          .where(exception_class: exception.exception_class)
+          .where("created_at >= ?", time_range.ago)
+          .count
+      else
+        0
+      end
+    end
+
+    def format_exception_for_banner(exception)
+      details = parse_exception_details(exception)
+
+      # Extract message
+      message = if details["message"].present?
+        details["message"].to_s
+      elsif exception.respond_to?(:message) && exception.message.present?
+        exception.message.to_s
+      else
+        String.new
+      end
+
+      # Extract location
+      location = if details["controller_name"] && details["action_name"]
+        "#{details['controller_name']}##{details['action_name']}"
+      else
+        String.new
+      end
+
+      {
+        title: exception_title(exception),
+        message: message.truncate(100),
+        location: location,
+        time: exception.created_at.strftime('%I:%M %p')
+      }
     end
 
     def no_exceptions_block

data/lib/newshound/middleware/banner_injector.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module Newshound
+  module Middleware
+    class BannerInjector
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, response = @app.call(env)
+
+        # Only inject into HTML responses
+        return [status, headers, response] unless html_response?(headers)
+        return [status, headers, response] unless status == 200
+
+        # Check authorization
+        controller = env['action_controller.instance']
+        return [status, headers, response] unless controller
+        return [status, headers, response] unless Newshound::Authorization.authorized?(controller)
+
+        # Get banner HTML
+        banner_html = generate_banner_html
+
+        # Inject banner after <body> tag
+        new_response = inject_banner(response, banner_html)
+
+        # Update Content-Length header
+        if headers['Content-Length']
+          headers['Content-Length'] = new_response.bytesize.to_s
+        end
+
+        [status, headers, [new_response]]
+      end
+
+      private
+
+      def html_response?(headers)
+        content_type = headers['Content-Type']
+        content_type && content_type.include?('text/html')
+      end
+
+      def inject_banner(response, banner_html)
+        body = response_body(response)
+
+        # Inject after <body> tag
+        body.sub(/(<body[^>]*>)/i, "\\1\n#{banner_html}")
+      end
+
+      def response_body(response)
+        body = String.new
+        response.each { |part| body << part }
+        body
+      end
+
+      def generate_banner_html
+        exception_reporter = Newshound::ExceptionReporter.new
+        que_reporter = Newshound::QueReporter.new
+
+        exception_data = exception_reporter.banner_data
+        job_data = que_reporter.banner_data
+
+        # Generate HTML from template
+        render_banner(exception_data, job_data)
+      end
+
+      def render_banner(exception_data, job_data)
+        <<~HTML
+          <div id="newshound-banner" class="newshound-banner newshound-collapsed">
+            #{render_styles}
+            <div class="newshound-header" onclick="document.getElementById('newshound-banner').classList.toggle('newshound-collapsed')">
+              <span class="newshound-title">
+                🐕 Newshound
+                #{summary_badge(exception_data, job_data)}
+              </span>
+              <span class="newshound-toggle">▼</span>
+            </div>
+            <div class="newshound-content">
+              #{render_exceptions(exception_data)}
+              #{render_jobs(job_data)}
+            </div>
+          </div>
+        HTML
+      end
+
+      def render_styles
+        <<~CSS
+          <style>
+            .newshound-banner {
+              position: fixed;
+              top: 0;
+              left: 0;
+              right: 0;
+              background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+              color: white;
+              z-index: 10000;
+              box-shadow: 0 2px 10px rgba(0,0,0,0.3);
+              font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+              font-size: 14px;
+            }
+            .newshound-header {
+              padding: 12px 20px;
+              cursor: pointer;
+              display: flex;
+              justify-content: space-between;
+              align-items: center;
+              user-select: none;
+            }
+            .newshound-title {
+              font-weight: 600;
+              display: flex;
+              align-items: center;
+              gap: 10px;
+            }
+            .newshound-badge {
+              display: inline-block;
+              padding: 2px 8px;
+              border-radius: 12px;
+              font-size: 12px;
+              font-weight: 600;
+              background: rgba(255,255,255,0.2);
+            }
+            .newshound-badge.error {
+              background: #ef4444;
+            }
+            .newshound-badge.warning {
+              background: #f59e0b;
+            }
+            .newshound-badge.success {
+              background: #10b981;
+            }
+            .newshound-toggle {
+              transition: transform 0.3s;
+            }
+            .newshound-banner.newshound-collapsed .newshound-toggle {
+              transform: rotate(-90deg);
+            }
+            .newshound-content {
+              max-height: 400px;
+              overflow-y: auto;
+              border-top: 1px solid rgba(255,255,255,0.2);
+              transition: max-height 0.3s ease-out;
+            }
+            .newshound-banner.newshound-collapsed .newshound-content {
+              max-height: 0;
+              overflow: hidden;
+              border-top: none;
+            }
+            .newshound-section {
+              padding: 15px 20px;
+              border-bottom: 1px solid rgba(255,255,255,0.1);
+            }
+            .newshound-section:last-child {
+              border-bottom: none;
+            }
+            .newshound-section-title {
+              font-weight: 600;
+              margin-bottom: 10px;
+              font-size: 15px;
+            }
+            .newshound-item {
+              background: rgba(255,255,255,0.1);
+              padding: 10px;
+              margin-bottom: 8px;
+              border-radius: 6px;
+              font-size: 13px;
+            }
+            .newshound-item:last-child {
+              margin-bottom: 0;
+            }
+            .newshound-item-title {
+              font-weight: 600;
+              margin-bottom: 4px;
+            }
+            .newshound-item-detail {
+              opacity: 0.9;
+              font-size: 12px;
+            }
+            .newshound-grid {
+              display: grid;
+              grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+              gap: 10px;
+            }
+            .newshound-stat {
+              background: rgba(255,255,255,0.1);
+              padding: 12px;
+              border-radius: 6px;
+              text-align: center;
+            }
+            .newshound-stat-value {
+              font-size: 24px;
+              font-weight: 700;
+              display: block;
+            }
+            .newshound-stat-label {
+              font-size: 11px;
+              opacity: 0.8;
+              text-transform: uppercase;
+              letter-spacing: 0.5px;
+            }
+          </style>
+        CSS
+      end
+
+      def summary_badge(exception_data, job_data)
+        exception_count = exception_data[:exceptions]&.length || 0
+        failed_jobs = job_data.dig(:queue_stats, :failed) || 0
+
+        if exception_count > 0 || failed_jobs > 10
+          badge_class = "error"
+          text = "#{exception_count} exceptions, #{failed_jobs} failed jobs"
+        elsif failed_jobs > 5
+          badge_class = "warning"
+          text = "#{failed_jobs} failed jobs"
+        else
+          badge_class = "success"
+          text = "All clear"
+        end
+
+        %(<span class="newshound-badge #{badge_class}">#{text}</span>)
+      end
+
+      def render_exceptions(data)
+        exceptions = data[:exceptions] || []
+
+        if exceptions.empty?
+          return %(<div class="newshound-section"><div class="newshound-section-title">✅ Exceptions</div><div class="newshound-item">No exceptions in the last 24 hours</div></div>)
+        end
+
+        items = exceptions.take(5).map do |ex|
+          <<~HTML
+            <div class="newshound-item">
+              <div class="newshound-item-title">#{escape_html(ex[:title])}</div>
+              <div class="newshound-item-detail">
+                #{escape_html(ex[:message])} • #{escape_html(ex[:location])} • #{escape_html(ex[:time])}
+              </div>
+            </div>
+          HTML
+        end.join
+
+        <<~HTML
+          <div class="newshound-section">
+            <div class="newshound-section-title">⚠️ Recent Exceptions (#{exceptions.length})</div>
+            #{items}
+          </div>
+        HTML
+      end
+
+      def render_jobs(data)
+        stats = data[:queue_stats] || {}
+
+        <<~HTML
+          <div class="newshound-section">
+            <div class="newshound-section-title">📊 Job Queue Status</div>
+            <div class="newshound-grid">
+              <div class="newshound-stat">
+                <span class="newshound-stat-value">#{stats[:ready_to_run] || 0}</span>
+                <span class="newshound-stat-label">Ready</span>
+              </div>
+              <div class="newshound-stat">
+                <span class="newshound-stat-value">#{stats[:scheduled] || 0}</span>
+                <span class="newshound-stat-label">Scheduled</span>
+              </div>
+              <div class="newshound-stat">
+                <span class="newshound-stat-value">#{stats[:failed] || 0}</span>
+                <span class="newshound-stat-label">Failed</span>
+              </div>
+              <div class="newshound-stat">
+                <span class="newshound-stat-value">#{stats[:completed_today] || 0}</span>
+                <span class="newshound-stat-label">Completed Today</span>
+              </div>
+            </div>
+          </div>
+        HTML
+      end
+
+      def escape_html(text)
+        return String.new unless text.present?
+        text.to_s
+          .gsub('&', '&amp;')
+          .gsub('<', '&lt;')
+          .gsub('>', '&gt;')
+          .gsub('"', '&quot;')
+          .gsub("'", '&#39;')
+      end
+    end
+  end
+end

data/lib/newshound/que_reporter.rb

@@ -22,6 +22,21 @@ module Newshound
         queue_health_section
       ].compact
     end
+    alias_method :report, :generate_report
+
+    # Returns data formatted for the banner UI
+    def banner_data
+      stats = queue_statistics
+
+      {
+        queue_stats: {
+          ready_to_run: stats[:ready],
+          scheduled: stats[:scheduled],
+          failed: stats[:failed],
+          completed_today: stats[:finished_today]
+        }
+      }
+    end
 
     private
 
@@ -42,21 +57,33 @@ module Newshound
     def job_counts_by_type
       return {} unless job_source
 
-      job_source
-        .group(:job_class)
-        .group(:error_count)
-        .count
-        .each_with_object({}) do |((job_class, error_count), count), hash|
-          hash[job_class] ||= { success: 0, failed: 0, total: 0 }
-          
-          if error_count.zero?
-            hash[job_class][:success] += count
-          else
-            hash[job_class][:failed] += count
-          end
-          
-          hash[job_class][:total] += count
+      # Use raw SQL since Que::Job may not support ActiveRecord's .group method
+      results = ActiveRecord::Base.connection.execute(<<~SQL)
+        SELECT job_class, error_count, COUNT(*) as count
+        FROM que_jobs
+        WHERE finished_at IS NULL
+        GROUP BY job_class, error_count
+        ORDER BY job_class
+      SQL
+
+      results.each_with_object({}) do |row, hash|
+        job_class = row["job_class"]
+        error_count = row["error_count"].to_i
+        count = row["count"].to_i
+
+        hash[job_class] ||= {success: 0, failed: 0, total: 0}
+
+        if error_count.zero?
+          hash[job_class][:success] += count
+        else
+          hash[job_class][:failed] += count
         end
+
+        hash[job_class][:total] += count
+      end
+    rescue StandardError => e
+      logger.error "Failed to fetch job counts: #{e.message}"
+      {}
     end
 
     def format_job_counts(counts)
@@ -85,20 +112,27 @@ module Newshound
     def queue_statistics
       return default_stats unless job_source
 
-      current_time = Time.now
-      beginning_of_day = Date.today.to_time
+      conn = ActiveRecord::Base.connection
+      current_time = conn.quote(Time.now)
+      beginning_of_day = conn.quote(Date.today.to_time)
 
       {
-        ready: job_source.where(finished_at: nil, expired_at: nil).where("run_at <= ?", current_time).count,
-        scheduled: job_source.where(finished_at: nil, expired_at: nil).where("run_at > ?", current_time).count,
-        failed: job_source.where.not(error_count: 0).where(finished_at: nil).count,
-        finished_today: job_source.where("finished_at >= ?", beginning_of_day).count
+        ready: count_jobs("finished_at IS NULL AND expired_at IS NULL AND run_at <= #{current_time}"),
+        scheduled: count_jobs("finished_at IS NULL AND expired_at IS NULL AND run_at > #{current_time}"),
+        failed: count_jobs("error_count > 0 AND finished_at IS NULL"),
+        finished_today: count_jobs("finished_at >= #{beginning_of_day}")
       }
     rescue StandardError => e
       logger.error "Failed to fetch Que statistics: #{e.message}"
       default_stats
     end
 
+    def count_jobs(where_clause)
+      ActiveRecord::Base.connection.select_value(
+        "SELECT COUNT(*) FROM que_jobs WHERE #{where_clause}"
+      ).to_i
+    end
+
     def default_stats
       { ready: 0, scheduled: 0, failed: 0, finished_today: 0 }
     end

data/lib/newshound/railtie.rb

@@ -4,59 +4,55 @@ require "rails/railtie"
 
 module Newshound
   class Railtie < Rails::Railtie
+    # Register middleware to inject banner
+    initializer "newshound.middleware" do |app|
+      if Newshound.configuration.enabled
+        app.middleware.use Newshound::Middleware::BannerInjector
+      end
+    end
+
     rake_tasks do
       namespace :newshound do
-        desc "Send daily report immediately"
-        task report_now: :environment do
-          puts "Sending Newshound daily report..."
-          Newshound.report!
-          puts "Report sent successfully!"
-        rescue StandardError => e
-          puts "Failed to send report: #{e.message}"
-        end
-
-        desc "Schedule daily report job"
-        task schedule: :environment do
-          puts "Scheduling Newshound daily report..."
-          Newshound::Scheduler.run_now!
-          puts "Job enqueued successfully!"
-        end
-
         desc "Show current configuration"
         task config: :environment do
           config = Newshound.configuration
           puts "Newshound Configuration:"
           puts "  Enabled: #{config.enabled}"
-          puts "  Slack Webhook: #{config.slack_webhook_url.present? ? '[CONFIGURED]' : '[NOT SET]'}"
-          puts "  Slack Channel: #{config.slack_channel}"
-          puts "  Report Time: #{config.report_time}"
           puts "  Exception Limit: #{config.exception_limit}"
-          puts "  Time Zone: #{config.time_zone}"
-          puts "  Valid: #{config.valid?}"
+          puts "  Authorized Roles: #{config.authorized_roles.join(', ')}"
+          puts "  Current User Method: #{config.current_user_method}"
+          puts "  Custom Authorization: #{config.authorization_block.present? ? 'Yes' : 'No'}"
+        end
+
+        desc "Test exception reporter"
+        task test_exceptions: :environment do
+          reporter = Newshound::ExceptionReporter.new
+          data = reporter.report
+          puts "Exception Report:"
+          puts "  Total exceptions: #{data[:exceptions]&.length || 0}"
+          data[:exceptions]&.each_with_index do |ex, i|
+            puts "  #{i + 1}. #{ex[:title]} - #{ex[:message]}"
+          end
         end
-      end
-    end
 
-    initializer "newshound.configure_que_scheduler" do
-      ActiveSupport.on_load(:active_record) do
-        if defined?(::Que::Scheduler)
-          require_relative "scheduler"
-          
-          # Add our job to the que-scheduler configuration
-          schedule = Newshound::Scheduler.schedule_daily_report
-          
-          Rails.logger.info "Newshound: Scheduled daily report at #{Newshound.configuration.report_time}"
-        else
-          Rails.logger.warn "Newshound: que-scheduler not found. Daily reports will need to be triggered manually."
+        desc "Test job reporter"
+        task test_jobs: :environment do
+          reporter = Newshound::QueReporter.new
+          data = reporter.report
+          puts "Job Queue Report:"
+          puts "  Ready to run: #{data.dig(:queue_stats, :ready_to_run)}"
+          puts "  Scheduled: #{data.dig(:queue_stats, :scheduled)}"
+          puts "  Failed: #{data.dig(:queue_stats, :failed)}"
+          puts "  Completed today: #{data.dig(:queue_stats, :completed_today)}"
         end
       end
     end
 
     config.after_initialize do
       if Newshound.configuration.valid?
-        Rails.logger.info "Newshound initialized and ready to report!"
+        Rails.logger.info "Newshound initialized - banner will be shown to authorized users"
       else
-        Rails.logger.warn "Newshound is not properly configured. Please check your configuration."
+        Rails.logger.warn "Newshound is disabled"
       end
     end
   end

data/lib/newshound/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Newshound
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

data/lib/newshound.rb

@@ -4,9 +4,8 @@ require_relative "newshound/version"
 require_relative "newshound/configuration"
 require_relative "newshound/exception_reporter"
 require_relative "newshound/que_reporter"
-require_relative "newshound/slack_notifier"
-require_relative "newshound/daily_report_job"
-require_relative "newshound/scheduler"
+require_relative "newshound/authorization"
+require_relative "newshound/middleware/banner_injector"
 require_relative "newshound/railtie" if defined?(Rails)
 
 module Newshound
@@ -21,46 +20,9 @@ module Newshound
       yield(configuration)
     end
 
-    def report!
-      slack_notifier = SlackNotifier.new
-      
-      exception_report = ExceptionReporter.new.generate_report
-      que_report = QueReporter.new.generate_report
-      
-      message = format_daily_report(exception_report, que_report)
-      slack_notifier.post(message)
-    end
-
-    private
-
-    def format_daily_report(exception_report, que_report)
-      {
-        blocks: [
-          {
-            type: "header",
-            text: {
-              type: "plain_text",
-              text: "🐕 Daily Newshound Report",
-              emoji: true
-            }
-          },
-          {
-            type: "section",
-            text: {
-              type: "mrkdwn",
-              text: "*Date:* #{Date.current.strftime('%B %d, %Y')}"
-            }
-          },
-          {
-            type: "divider"
-          },
-          *exception_report,
-          {
-            type: "divider"
-          },
-          *que_report
-        ]
-      }
+    # Allow setting custom authorization logic
+    def authorize_with(&block)
+      configuration.authorize_with(&block)
     end
   end
 end