newshound 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5541adbc8e4ccb311bcce9a185946affc52cddc3d6c253779722a4901627401
-  data.tar.gz: 06c86ac9f83a00ce6e6e77063131a29eaf2fb7e6643528e65e6f0b3c329d1309
+  metadata.gz: ed2c9eae65ac8681fc1c72890cbd421ca9dd73130c37fa86c04643cb74c03856
+  data.tar.gz: 7ccb875f08607e1478245384376a621243fdd44e40443fb191064210cff94ba6
 SHA512:
-  metadata.gz: 3d3e875cb30e1e3c27cd932f5f66fa8f9a6269d7e03c7cbb5428ce5ba47dd53acacb80721d5f51452b0d97a3d46a7005e93fec24c9954a96452ee861df6c962a
-  data.tar.gz: a5041975aab52ff2c50527f9f5050014d086908923b7f15830dce201f43a234a9086b3ba2d7747de90797ef07af0d769badbe431bd92105abd8b9e254f6b4499
+  metadata.gz: a78bd31f883c89116c83b7c77b680faba172b41e0bc3f375e4a81a075503d33860ebd4778e71f11d868a794fe04effd815e240ebd3d5c6135b0ed80599c87469
+  data.tar.gz: 4985d3d128688284f4734391b12e7f6e34d1c69857d713d3995d2078cc4df210b64ca5f84d889841e52b1b3a9086bcf0f19e7d35bef646b60e08020379527ad6

data/README.md

@@ -1,187 +1,192 @@
 # Newshound 🐕
 
-A Ruby gem that sniffs out exceptions and job statuses in your Rails app and reports them daily to Slack or other notification services.
+A Ruby gem that displays real-time exceptions and job statuses in a collapsible banner for authorized users in your Rails application.
 
 ## Features
 
-- 📊 Daily Que job status reports (counts by job type, queue health)
-- 🚨 Last 4 exceptions from exception-track
-- 💬 Multiple transport options: Direct Slack or Amazon SNS
-- ⏰ Automatic daily scheduling with que-scheduler
-- 🔧 Configurable report times and limits
-- 🔄 Environment-based transport switching (SNS for production, Slack for development)
+- 🎯 **Real-time Web UI Banner** - Shows exceptions and job statuses at the top of every page
+- 🔐 **Role-Based Access** - Only visible to authorized users (developers, admins, etc.)
+- 📊 **Que Job Monitoring** - Real-time queue health and job status
+- 🚨 **Exception Tracking** - Recent exceptions from exception-track
+- 🎨 **Collapsible UI** - Clean, non-intrusive banner that expands on click
+- ⚡ **Zero Configuration** - Automatically injects into HTML responses
+- 🔧 **Highly Customizable** - Configure roles and authorization logic
 
 ## Installation
 
 Add to your Gemfile:
 
 ```ruby
-gem 'newshound', path: 'path/to/newshound'  # or from git/rubygems when published
-
-# Optional: Add AWS SDK if using SNS transport
-gem 'aws-sdk-sns', '~> 1.0'  # Only needed for SNS transport
+gem 'newshound'
 ```
 
 Then:
 
 ```bash
 bundle install
+rails generate newshound:install
 ```
 
-## Configuration
+The generator will create `config/initializers/newshound.rb` with default configuration.
 
-Create an initializer `config/initializers/newshound.rb`:
+## Configuration
 
-### Basic Configuration (Slack Direct)
+### Basic Configuration
 
 ```ruby
+# config/initializers/newshound.rb
 Newshound.configure do |config|
-  # Transport selection (optional, defaults to :slack)
-  config.transport_adapter = :slack
-
-  # Slack configuration (choose one method)
-  config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']  # Option 1: Webhook
-  # OR set ENV['SLACK_API_TOKEN'] for Web API          # Option 2: Web API
-
-  config.slack_channel = "#ops-alerts"     # Default: "#general"
-  config.report_time = "09:00"            # Default: "09:00" (24-hour format)
-  config.exception_limit = 4              # Default: 4 (last N exceptions)
-  config.time_zone = "America/New_York"   # Default: "America/New_York"
-  config.enabled = true                   # Default: true
+  # Enable or disable the banner
+  config.enabled = true
+
+  # Maximum number of exceptions to show in banner
+  config.exception_limit = 10
+
+  # User roles that can view the banner
+  config.authorized_roles = [:developer, :super_user]
+
+  # Method to call to get current user (most apps use :current_user)
+  config.current_user_method = :current_user
 end
 ```
 
-### Production Configuration with SNS
+### Advanced: Custom Authorization
+
+If the default role-based authorization doesn't fit your needs, you can provide custom logic:
 
 ```ruby
-Newshound.configure do |config|
-  if Rails.env.production?
-    # Use SNS in production to route through AWS
-    config.transport_adapter = :sns
-    config.sns_topic_arn = ENV['SNS_TOPIC_ARN']
-    config.aws_region = ENV['AWS_REGION'] || 'us-east-1'
-
-    # Optional: Explicit AWS credentials (uses IAM role by default)
-    config.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID']
-    config.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
-  else
-    # Use direct Slack in development/staging
-    config.transport_adapter = :slack
-    config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
-  end
+# config/initializers/newshound.rb
+Newshound.authorize_with do |controller|
+  # Your custom authorization logic
+  # Return true to show banner, false to hide
+  user = controller.current_user
+  user&.admin? || user&.developer?
+end
+```
 
-  # Common settings
-  config.slack_channel = "#ops-alerts"
-  config.report_time = "09:00"
-  config.exception_limit = 4
-  config.time_zone = "America/New_York"
-  config.enabled = true
+### Example Authorization Scenarios
+
+```ruby
+# Only show in development
+Newshound.authorize_with do |controller|
+  Rails.env.development?
+end
+
+# Check multiple conditions
+Newshound.authorize_with do |controller|
+  user = controller.current_user
+  user.present? &&
+    (user.has_role?(:admin) || user.email.ends_with?('@yourcompany.com'))
+end
+
+# Use your existing authorization system
+Newshound.authorize_with do |controller|
+  controller.current_user&.can?(:view_newshound)
 end
 ```
 
-## Transport Setup
-
-### Slack Setup (Direct Integration)
-
-#### Option 1: Webhook URL (Simpler)
-1. Go to https://api.slack.com/apps
-2. Create a new app or select existing
-3. Enable "Incoming Webhooks"
-4. Add a new webhook for your channel
-5. Copy the webhook URL to your config
-
-#### Option 2: Web API Token (More features)
-1. Create a Slack app at https://api.slack.com/apps
-2. Add OAuth scopes: `chat:write`, `chat:write.public`
-3. Install to workspace
-4. Copy the Bot User OAuth Token
-5. Set as `ENV['SLACK_API_TOKEN']`
-
-### AWS SNS Setup (Production Routing)
-
-1. **Create SNS Topic**:
-   ```bash
-   aws sns create-topic --name newshound-notifications
-   ```
-
-2. **Subscribe Slack Webhook to Topic**:
-   ```bash
-   aws sns subscribe \
-     --topic-arn arn:aws:sns:us-east-1:123456789:newshound-notifications \
-     --protocol https \
-     --notification-endpoint YOUR_SLACK_WEBHOOK_URL
-   ```
-
-3. **Configure IAM Permissions**:
-   ```json
-   {
-     "Version": "2012-10-17",
-     "Statement": [{
-       "Effect": "Allow",
-       "Action": "sns:Publish",
-       "Resource": "arn:aws:sns:us-east-1:*:newshound-*"
-     }]
-   }
-   ```
-
-4. **Set Environment Variables**:
-   ```bash
-   export SNS_TOPIC_ARN="arn:aws:sns:us-east-1:123456789:newshound-notifications"
-   export AWS_REGION="us-east-1"
-   ```
-
-## Usage
-
-### Automatic Daily Reports
-
-If you have `que-scheduler` configured, Newshound will automatically schedule daily reports at your configured time.
-
-### Manual Reports
+## How It Works
+
+Newshound uses Rails middleware to automatically inject a banner into HTML responses for authorized users. The banner:
+
+1. ✅ Appears automatically on all HTML pages
+2. 🔒 Only visible to users with authorized roles
+3. 📊 Shows real-time data from your exception and job queues
+4. 🎨 Collapses to save space, expands on click
+5. 🚀 No JavaScript dependencies, pure CSS animations
+
+## Banner Content
+
+The banner displays:
+
+### Exception Section
+- Recent exceptions from exception-track
+- Exception class and message
+- Controller/action where it occurred
+- Timestamp
+- Visual indicators (🟢 all clear / 🔴 errors)
+
+### Job Queue Section
+- **Ready to Run**: Jobs waiting to execute
+- **Scheduled**: Jobs scheduled for future execution
+- **Failed**: Jobs in retry queue
+- **Completed Today**: Successfully finished jobs
+- Color-coded health status
+
+## User Requirements
+
+Your User model should have a `role` attribute that matches one of the configured `authorized_roles`. Common patterns:
 
 ```ruby
-# Send report immediately
-Newshound.report!
+# String enum
+class User < ApplicationRecord
+  enum role: { user: 'user', developer: 'developer', admin: 'admin' }
+end
+
+# Symbol enum
+class User < ApplicationRecord
+  enum role: { user: 0, developer: 1, super_user: 2 }
+end
+
+# String column
+class User < ApplicationRecord
+  def role
+    @role ||= read_attribute(:role)&.to_sym
+  end
+end
+```
+
+If your User model uses different attribute names, you can customize the authorization logic using `Newshound.authorize_with`.
+
+## Testing
+
+### Test Reporters
 
-# Or via rake task
-rake newshound:report_now
+```bash
+# Test exception reporter
+rake newshound:test_exceptions
 
-# Enqueue for background processing
-rake newshound:schedule
+# Test job queue reporter
+rake newshound:test_jobs
 
-# Check configuration
+# Show current configuration
 rake newshound:config
 ```
 
-### Integration with que-scheduler
-
-Add to your `config/que_schedule.yml`:
+### Test in Rails Console
 
-```yaml
-newshound_daily_report:
-  class: "Newshound::DailyReportJob"
-  cron: "0 9 * * *"  # 9:00 AM daily
-  queue: default
+```ruby
+# Check if banner would show for a specific user
+user = User.find(123)
+controller = ApplicationController.new
+controller.instance_variable_set(:@current_user, user)
+Newshound::Authorization.authorized?(controller)
+# => true or false
 ```
 
-Or let Newshound auto-configure based on your settings.
+## Troubleshooting
 
-## Report Format
+### Banner not appearing
 
-The daily report includes:
+1. **Check if enabled**: `rake newshound:config`
+2. **Verify user role**: Make sure your user has an authorized role
+3. **Check current_user method**: Ensure your app provides the configured method
+4. **Restart server**: Changes to initializers require a restart
 
-### Exception Section
-- Last 4 exceptions (configurable)
-- Exception class, message, controller/action
-- Count of same exception type in last 24 hours
-- Timestamp
+### No exceptions showing
+
+- Ensure `exception-track` gem is installed and logging exceptions
+- Check that exceptions exist: `rake newshound:test_exceptions`
 
-### Que Jobs Section
-- Job counts by type (success/failed/total)
-- Queue health status
-- Ready to run count
-- Scheduled jobs count
-- Failed jobs in retry queue
-- Jobs completed today
+### No job data
+
+- Verify Que is configured and `que_jobs` table exists
+- Check job data: `rake newshound:test_jobs`
+
+### Banner appears for wrong users
+
+- Review `authorized_roles` configuration
+- Consider using custom authorization with `Newshound.authorize_with`
 
 ## Development
 
@@ -196,30 +201,22 @@ bundle exec rubocop
 bin/console
 ```
 
-## Testing in Your App
+## Dependencies
 
-```ruby
-# In rails console
+- **Rails** >= 6.0
+- **que** >= 1.0 (for job monitoring)
+- **exception-track** >= 0.1 (for exception tracking)
 
-# Test Slack transport
-Newshound.configuration.transport_adapter = :slack
-Newshound.configuration.slack_webhook_url = "your-webhook"
-Newshound.report!  # Should post to Slack immediately
+## Upgrading from 0.1.x
 
-# Test SNS transport
-Newshound.configuration.transport_adapter = :sns
-Newshound.configuration.sns_topic_arn = "your-topic-arn"
-Newshound.report!  # Should publish to SNS
-```
+If you were using the previous Slack-based version:
 
-## Troubleshooting
+1. Remove Slack/SNS configuration from your initializer
+2. Remove `que-scheduler` if only used for Newshound
+3. Update to new configuration format (see above)
+4. Restart your Rails server
 
-- **No reports sent**: Check `rake newshound:config` to verify configuration
-- **No exceptions showing**: Ensure `exception-track` gem is installed and logging
-- **No job data**: Verify Que is configured and `que_jobs` table exists
-- **Slack not receiving**: Verify webhook URL or API token is correct
-- **SNS not publishing**: Check IAM permissions and topic ARN configuration
-- **AWS SDK errors**: Ensure `aws-sdk-sns` gem is installed when using SNS transport
+The banner will now appear automatically for authorized users instead of sending Slack notifications.
 
 ## License
 

data/lib/generators/newshound/install/install_generator.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "rails/generators"
-require "yaml"
 
 module Newshound
   module Generators
@@ -14,62 +13,22 @@ module Newshound
         template "newshound.rb", "config/initializers/newshound.rb"
       end
 
-      def add_to_que_schedule
-        que_schedule_path = "config/que_schedule.yml"
-
-        if File.exist?(que_schedule_path)
-          say_status :info, "Adding Newshound job to #{que_schedule_path}", :blue
-
-          # Read existing YAML
-          existing_config = YAML.load_file(que_schedule_path) || {}
-
-          # Add Newshound job if not already present
-          unless existing_config.key?("Newshound::DailyReportJob")
-            # Append the configuration to the file
-            append_to_file que_schedule_path do
-              <<~YAML
-
-                # Newshound daily report job - sends exception and queue reports to Slack
-                Newshound::DailyReportJob:
-                  cron: "0 9 * * *"  # Daily at 9:00 AM - adjust as needed
-                  queue: default
-                  args: []
-              YAML
-            end
-
-            say_status :success, "Added Newshound::DailyReportJob to que_schedule.yml", :green
-          else
-            say_status :skip, "Newshound::DailyReportJob already exists in que_schedule.yml", :yellow
-          end
-        else
-          say_status :warning, "#{que_schedule_path} not found. Creating it with Newshound job.", :yellow
-          create_file que_schedule_path do
-            <<~YAML
-              # Que-scheduler configuration
-              # See https://github.com/hlascelles/que-scheduler for more information
-
-              # Newshound daily report job - sends exception and queue reports to Slack
-              Newshound::DailyReportJob:
-                cron: "0 9 * * *"  # Daily at 9:00 AM - adjust as needed
-                queue: default
-                args: []
-            YAML
-          end
-        end
-      end
-
       def display_post_install_message
         say ""
         say "===============================================================================", :green
         say "  Newshound has been successfully installed!", :green
         say ""
         say "  Next steps:", :yellow
-        say "  1. Configure your Slack webhook URL in config/initializers/newshound.rb"
-        say "  2. Adjust the report schedule in config/que_schedule.yml if needed"
-        say "  3. Restart your Rails server and Que workers"
+        say "  1. Configure authorized roles in config/initializers/newshound.rb"
+        say "  2. Make sure your User model has a role attribute (or customize authorization)"
+        say "  3. Restart your Rails server"
+        say ""
+        say "  The Newshound banner will automatically appear at the top of pages for"
+        say "  authorized users (developers and super_users by default)."
         say ""
-        say "  To test your configuration, run:", :cyan
-        say "    rails runner 'Newshound.report!'"
+        say "  To test the reporters, run:", :cyan
+        say "    rake newshound:test_exceptions"
+        say "    rake newshound:test_jobs"
         say ""
         say "  For more information, visit:", :blue
         say "    https://github.com/salbanez/newshound"

data/lib/generators/newshound/install/templates/newshound.rb

@@ -1,38 +1,32 @@
 # frozen_string_literal: true
 
 Newshound.configure do |config|
-  # Slack webhook URL for sending reports (required)
-  # You can get this from your Slack app settings
-  config.slack_webhook_url = ENV.fetch("NEWSHOUND_SLACK_WEBHOOK_URL", nil)
-
-  # Channel to post reports to
-  # Default is "#general"
-  config.slack_channel = "#engineering"
-
-  # Time to send daily report (24-hour format)
-  # Default is "09:00" (9:00 AM)
-  config.report_time = "09:00"
-
-  # Maximum number of exceptions to include in report
-  # Default is 4
-  config.exception_limit = 4
-
-  # Time zone for scheduling reports
-  # Default is "America/New_York"
-  config.time_zone = "America/New_York"
-
   # Enable or disable Newshound completely
-  # Useful for disabling in development/test environments
+  # When enabled, the banner will be shown to authorized users
   # Default is true
-  config.enabled = Rails.env.production?
-
-  # Transport adapter (:slack or :sns)
-  # Default is :slack
-  config.transport_adapter = :slack
-
-  # AWS SNS Configuration (only needed if transport_adapter is :sns)
-  # config.sns_topic_arn = ENV.fetch("NEWSHOUND_SNS_TOPIC_ARN", nil)
-  # config.aws_region = ENV.fetch("AWS_REGION", "us-east-1")
-  # config.aws_access_key_id = ENV.fetch("AWS_ACCESS_KEY_ID", nil)
-  # config.aws_secret_access_key = ENV.fetch("AWS_SECRET_ACCESS_KEY", nil)
-end
+  config.enabled = true
+
+  # Maximum number of exceptions to include in banner
+  # Default is 10
+  config.exception_limit = 10
+
+  # User roles that are authorized to view the Newshound banner
+  # These should match the role values in your User model
+  # Default is [:developer, :super_user]
+  config.authorized_roles = [:developer, :super_user]
+
+  # Method name to call to get the current user
+  # Most apps use :current_user (Devise, etc.)
+  # Default is :current_user
+  config.current_user_method = :current_user
+end
+
+# Advanced: Custom authorization logic
+# If the default role-based authorization doesn't fit your needs,
+# you can provide a custom authorization block:
+#
+# Newshound.authorize_with do |controller|
+#   # Your custom logic here
+#   # Return true to show the banner, false to hide it
+#   controller.current_user&.admin?
+# end

data/lib/newshound/authorization.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Newshound
+  module Authorization
+    class << self
+      # Check if the current user/controller is authorized to view Newshound data
+      def authorized?(controller)
+        return false unless Newshound.configuration.enabled
+
+        # Use custom authorization block if provided
+        if Newshound.configuration.authorization_block
+          return Newshound.configuration.authorization_block.call(controller)
+        end
+
+        # Default authorization: check if current_user has an authorized role
+        user = current_user_from(controller)
+        return false unless user
+
+        user_role = user_role_from(user)
+        return false unless user_role
+
+        Newshound.configuration.authorized_roles.include?(user_role.to_sym)
+      end
+
+      private
+
+      def current_user_from(controller)
+        method_name = Newshound.configuration.current_user_method
+        return nil unless controller.respond_to?(method_name)
+
+        controller.send(method_name)
+      end
+
+      def user_role_from(user)
+        return nil unless user
+
+        # Try common role attribute names
+        [:role, :user_role, :type].each do |attr|
+          return user.send(attr) if user.respond_to?(attr)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/newshound/configuration.rb

@@ -2,30 +2,24 @@
 
 module Newshound
   class Configuration
-    attr_accessor :slack_webhook_url, :slack_channel, :report_time,
-                  :exception_limit, :time_zone, :enabled,
-                  :transport_adapter, :sns_topic_arn, :aws_region,
-                  :aws_access_key_id, :aws_secret_access_key
+    attr_accessor :exception_limit, :enabled, :authorized_roles,
+                  :current_user_method, :authorization_block
 
     def initialize
-      @slack_webhook_url = nil
-      @slack_channel = "#general"
-      @report_time = "09:00"
-      @exception_limit = 4
-      @time_zone = "America/New_York"
+      @exception_limit = 10
       @enabled = true
-      @transport_adapter = :slack
-      @sns_topic_arn = nil
-      @aws_region = nil
-      @aws_access_key_id = nil
-      @aws_secret_access_key = nil
+      @authorized_roles = [:developer, :super_user]
+      @current_user_method = :current_user
+      @authorization_block = nil
+    end
+
+    # Allow custom authorization logic
+    def authorize_with(&block)
+      @authorization_block = block
     end
 
     def valid?
-      return false unless enabled
-      return false if slack_webhook_url.nil? || slack_webhook_url.empty?
-      
-      true
+      enabled
     end
   end
 end