newshound 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: decd51fd02b481edd644a56bd700575010ae0b3d747fc2880803c68c32e50bfa
-  data.tar.gz: f44304b8a0f6621296ff13900a2e59ea702b62c08ed6491ad0a60b4839b76b6d
+  metadata.gz: b5541adbc8e4ccb311bcce9a185946affc52cddc3d6c253779722a4901627401
+  data.tar.gz: 06c86ac9f83a00ce6e6e77063131a29eaf2fb7e6643528e65e6f0b3c329d1309
 SHA512:
-  metadata.gz: 813c1c7d310854f34722819c8321d24438cafd543bf9c4dcf164e90bcf716423953ae0583656fe97476d454342fb8c4dabdfa48b66d886d6adb21abc6466521b
-  data.tar.gz: 6c60ed849cd31e6e08066dc9893c2dcd3d3a82450923d97383717f2c5e21f2ea4943880b73ccce9926cbed83ead51b9cea0b2c08c91ba1fb8b63a6a8fb66e983
+  metadata.gz: 3d3e875cb30e1e3c27cd932f5f66fa8f9a6269d7e03c7cbb5428ce5ba47dd53acacb80721d5f51452b0d97a3d46a7005e93fec24c9954a96452ee861df6c962a
+  data.tar.gz: a5041975aab52ff2c50527f9f5050014d086908923b7f15830dce201f43a234a9086b3ba2d7747de90797ef07af0d769badbe431bd92105abd8b9e254f6b4499

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.4.3

data/Gemfile

@@ -4,6 +4,12 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "rake", "~> 13.0"
-gem "rspec", "~> 3.0"
-gem "rubocop", "~> 1.0"
+group :development, :test do
+  gem "bundler", "~> 2.0"
+  gem "rake", "~> 13.0"
+  gem "rspec", "~> 3.0"
+  gem "rubocop", "~> 1.0"
+  gem "pg"
+  gem "pry"
+  gem "simplecov", require: false
+end

data/README.md

@@ -1,14 +1,15 @@
 # Newshound 🐕
 
-A Ruby gem that sniffs out exceptions and job statuses in your Rails app and reports them daily to Slack.
+A Ruby gem that sniffs out exceptions and job statuses in your Rails app and reports them daily to Slack or other notification services.
 
 ## Features
 
 - 📊 Daily Que job status reports (counts by job type, queue health)
 - 🚨 Last 4 exceptions from exception-track
-- 💬 Slack integration via webhook or Web API
+- 💬 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)
 
 ## Installation
 
@@ -16,6 +17,9 @@ 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
 ```
 
 Then:
@@ -28,12 +32,17 @@ bundle install
 
 Create an initializer `config/initializers/newshound.rb`:
 
+### Basic Configuration (Slack Direct)
+
 ```ruby
 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)
@@ -42,7 +51,37 @@ Newshound.configure do |config|
 end
 ```
 
-### Slack Setup
+### Production Configuration with SNS
+
+```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
+
+  # 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
+end
+```
+
+## Transport Setup
+
+### Slack Setup (Direct Integration)
 
 #### Option 1: Webhook URL (Simpler)
 1. Go to https://api.slack.com/apps
@@ -58,6 +97,39 @@ end
 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
@@ -128,8 +200,16 @@ bin/console
 
 ```ruby
 # In rails console
+
+# Test Slack transport
+Newshound.configuration.transport_adapter = :slack
 Newshound.configuration.slack_webhook_url = "your-webhook"
 Newshound.report!  # Should post to Slack immediately
+
+# Test SNS transport
+Newshound.configuration.transport_adapter = :sns
+Newshound.configuration.sns_topic_arn = "your-topic-arn"
+Newshound.report!  # Should publish to SNS
 ```
 
 ## Troubleshooting
@@ -138,6 +218,8 @@ Newshound.report!  # Should post to Slack immediately
 - **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
 
 ## License
 

data/TRANSPORT_USAGE.md

@@ -0,0 +1,117 @@
+# Transport Layer Usage
+
+The Newshound gem now supports multiple transport adapters for sending notifications. You can choose between Slack (direct) and Amazon SNS based on your environment needs.
+
+## Configuration
+
+### Using Slack Transport (Default)
+
+```ruby
+# config/initializers/newshound.rb
+Newshound.configure do |config|
+  config.transport_adapter = :slack  # This is the default
+  config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
+  config.slack_channel = '#your-channel'
+  # ... other configurations
+end
+```
+
+### Using SNS Transport
+
+```ruby
+# config/initializers/newshound.rb
+Newshound.configure do |config|
+  config.transport_adapter = :sns
+  config.sns_topic_arn = ENV['SNS_TOPIC_ARN']
+  config.aws_region = ENV['AWS_REGION'] || 'us-east-1'
+
+  # Optional: Provide AWS credentials explicitly
+  # If not provided, will use default AWS credential chain
+  config.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID']
+  config.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+
+  # ... other configurations
+end
+```
+
+### Environment-based Configuration
+
+You can switch transport based on environment:
+
+```ruby
+# config/initializers/newshound.rb
+Newshound.configure do |config|
+  if Rails.env.production?
+    # Use SNS in production to route through AWS infrastructure
+    config.transport_adapter = :sns
+    config.sns_topic_arn = ENV['SNS_TOPIC_ARN']
+    config.aws_region = ENV['AWS_REGION']
+  else
+    # Use direct Slack in development/staging
+    config.transport_adapter = :slack
+    config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
+    config.slack_channel = '#dev-notifications'
+  end
+
+  # Common configurations
+  config.report_time = "09:00"
+  config.exception_limit = 4
+  config.time_zone = "America/New_York"
+end
+```
+
+## Custom Transport Adapters
+
+You can also create your own transport adapter:
+
+```ruby
+class MyCustomTransport < Newshound::Transport::Base
+  def deliver(message)
+    # Your custom delivery logic here
+    # Return true on success, false on failure
+
+    # Example: Send to custom API endpoint
+    response = HTTParty.post(
+      'https://api.example.com/notifications',
+      body: message.to_json,
+      headers: { 'Content-Type' => 'application/json' }
+    )
+
+    response.success?
+  rescue StandardError => e
+    logger.error "Failed to deliver: #{e.message}"
+    false
+  end
+end
+
+# Use the custom transport
+Newshound.configure do |config|
+  config.transport_adapter = MyCustomTransport
+  # ... other configurations
+end
+```
+
+## AWS SNS Setup
+
+If using SNS transport, ensure you have:
+
+1. Created an SNS topic in AWS
+2. Subscribed your Slack webhook URL to the SNS topic
+3. Configured proper IAM permissions for publishing to the topic
+4. Installed the aws-sdk-sns gem (it's optional):
+
+```ruby
+# Add to your Gemfile if using SNS
+gem 'aws-sdk-sns', '~> 1.0'
+```
+
+## Testing
+
+The transport layer is fully testable. You can inject mock transports in your tests:
+
+```ruby
+# In your tests
+mock_transport = double('Transport', deliver: true)
+notifier = Newshound::SlackNotifier.new(transport: mock_transport)
+notifier.post({ text: "Test message" })
+```

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "yaml"
+
+module Newshound
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Configures Newshound for your Rails application"
+
+      def create_initializer
+        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 ""
+        say "  To test your configuration, run:", :cyan
+        say "    rails runner 'Newshound.report!'"
+        say ""
+        say "  For more information, visit:", :blue
+        say "    https://github.com/salbanez/newshound"
+        say "===============================================================================", :green
+        say ""
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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
+  # 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

data/lib/newshound/configuration.rb

@@ -3,7 +3,9 @@
 module Newshound
   class Configuration
     attr_accessor :slack_webhook_url, :slack_channel, :report_time,
-                  :exception_limit, :time_zone, :enabled
+                  :exception_limit, :time_zone, :enabled,
+                  :transport_adapter, :sns_topic_arn, :aws_region,
+                  :aws_access_key_id, :aws_secret_access_key
 
     def initialize
       @slack_webhook_url = nil
@@ -12,6 +14,11 @@ module Newshound
       @exception_limit = 4
       @time_zone = "America/New_York"
       @enabled = true
+      @transport_adapter = :slack
+      @sns_topic_arn = nil
+      @aws_region = nil
+      @aws_access_key_id = nil
+      @aws_secret_access_key = nil
     end
 
     def valid?

data/lib/newshound/daily_report_job.rb

@@ -1,19 +1,31 @@
 # frozen_string_literal: true
 
 module Newshound
-  class DailyReportJob < ::Que::Job
-    def run
-      return unless Newshound.configuration.valid?
-      
-      Newshound.report!
-      
-      destroy
-    rescue StandardError => e
-      Rails.logger.error "Newshound::DailyReportJob failed: #{e.message}"
-      Rails.logger.error e.backtrace.join("\n")
-      
-      # Re-raise to let Que handle retry logic
-      raise
+  if defined?(::Que::Job)
+    class DailyReportJob < ::Que::Job
+      def run
+        return unless Newshound.configuration.valid?
+
+        Newshound.report!
+
+        destroy
+      rescue StandardError => e
+        Rails.logger.error "Newshound::DailyReportJob failed: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+
+        # Re-raise to let Que handle retry logic
+        raise
+      end
+    end
+  else
+    class DailyReportJob
+      def self.enqueue(*args)
+        Rails.logger.warn "Que is not available. DailyReportJob cannot be enqueued."
+      end
+
+      def run
+        Rails.logger.warn "Que is not available. DailyReportJob cannot be run."
+      end
     end
   end
 end

data/lib/newshound/exception_reporter.rb

@@ -2,9 +2,17 @@
 
 module Newshound
   class ExceptionReporter
+    attr_reader :exception_source, :configuration, :time_range
+
+    def initialize(exception_source: nil, configuration: nil, time_range: 24.hours)
+      @exception_source = exception_source || (defined?(ExceptionTrack::Log) ? ExceptionTrack::Log : nil)
+      @configuration = configuration || Newshound.configuration
+      @time_range = time_range
+    end
+
     def generate_report
       return no_exceptions_block if recent_exceptions.empty?
-      
+
       [
         {
           type: "section",
@@ -24,12 +32,12 @@ module Newshound
     end
 
     def fetch_recent_exceptions
-      return [] unless defined?(ExceptionTrack::Log)
-      
-      ExceptionTrack::Log
-        .where("created_at >= ?", 24.hours.ago)
+      return [] unless exception_source
+
+      exception_source
+        .where("created_at >= ?", time_range.ago)
         .order(created_at: :desc)
-        .limit(Newshound.configuration.exception_limit)
+        .limit(configuration.exception_limit)
     end
 
     def format_exceptions
@@ -62,9 +70,11 @@ module Newshound
     end
 
     def exception_count(exception)
-      ExceptionTrack::Log
+      return 0 unless exception_source
+
+      exception_source
         .where(exception_class: exception.exception_class)
-        .where("created_at >= ?", 24.hours.ago)
+        .where("created_at >= ?", time_range.ago)
         .count
     end
 

data/lib/newshound/que_reporter.rb

@@ -2,6 +2,13 @@
 
 module Newshound
   class QueReporter
+    attr_reader :job_source, :logger
+
+    def initialize(job_source: nil, logger: nil)
+      @job_source = job_source || (defined?(::Que::Job) ? ::Que::Job : nil)
+      @logger = logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+    end
+
     def generate_report
       [
         {
@@ -33,9 +40,9 @@ module Newshound
     end
 
     def job_counts_by_type
-      return {} unless defined?(::Que::Job)
-      
-      ::Que::Job
+      return {} unless job_source
+
+      job_source
         .group(:job_class)
         .group(:error_count)
         .count
@@ -76,16 +83,19 @@ module Newshound
     end
 
     def queue_statistics
-      return default_stats unless defined?(::Que::Job)
-      
+      return default_stats unless job_source
+
+      current_time = Time.now
+      beginning_of_day = Date.today.to_time
+
       {
-        ready: ::Que::Job.where(finished_at: nil, expired_at: nil).where("run_at <= ?", Time.current).count,
-        scheduled: ::Que::Job.where(finished_at: nil, expired_at: nil).where("run_at > ?", Time.current).count,
-        failed: ::Que::Job.where.not(error_count: 0).where(finished_at: nil).count,
-        finished_today: ::Que::Job.where("finished_at >= ?", Date.current.beginning_of_day).count
+        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
       }
     rescue StandardError => e
-      Rails.logger.error "Failed to fetch Que statistics: #{e.message}"
+      logger.error "Failed to fetch Que statistics: #{e.message}"
       default_stats
     end
 

data/lib/newshound/scheduler.rb

@@ -4,12 +4,13 @@ module Newshound
   class Scheduler
     def self.schedule_daily_report
       return unless defined?(::Que::Scheduler)
-      
+
       config = Newshound.configuration
       return unless config.valid?
-      
-      # Schedule the job using que-scheduler
-      # This will be picked up by que-scheduler's configuration
+
+      # Note: Que-scheduler uses a YAML config file (config/que_schedule.yml)
+      # This method returns the configuration that should be added to that file
+      # or can be used to manually schedule the job
       schedule_config = {
         "newshound_daily_report" => {
           "class" => "Newshound::DailyReportJob",
@@ -18,12 +19,12 @@ module Newshound
           "args" => []
         }
       }
-      
-      # Merge with existing schedule if any
-      if defined?(::Que::Scheduler.configuration)
-        ::Que::Scheduler.configuration.merge!(schedule_config)
+
+      # Log the configuration for visibility
+      if defined?(Rails) && Rails.logger
+        Rails.logger.info "Newshound daily report scheduled for #{config.report_time} (cron: #{schedule_config['newshound_daily_report']['cron']})"
       end
-      
+
       schedule_config
     end
 

data/lib/newshound/slack_notifier.rb

@@ -4,58 +4,41 @@ require "slack-ruby-client"
 
 module Newshound
   class SlackNotifier
-    def initialize
-      configure_slack_client
+    attr_reader :configuration, :logger, :transport
+
+    def initialize(configuration: nil, logger: nil, transport: nil)
+      @configuration = configuration || Newshound.configuration
+      @logger = logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+      @transport = transport || build_transport
     end
 
     def post(message)
-      return unless valid_configuration?
-      
-      if webhook_configured?
-        post_via_webhook(message)
-      elsif web_api_configured?
-        post_via_web_api(message)
-      else
-        Rails.logger.error "Newshound: No valid Slack configuration found"
-      end
+      return unless configuration.valid?
+
+      transport.deliver(message)
     rescue StandardError => e
-      Rails.logger.error "Newshound: Failed to send Slack notification: #{e.message}"
+      logger.error "Newshound: Failed to send notification: #{e.message}"
     end
 
     private
 
-    def configure_slack_client
-      Slack.configure do |config|
-        config.token = ENV["SLACK_API_TOKEN"] if ENV["SLACK_API_TOKEN"]
+    def build_transport
+      case configuration.transport_adapter
+      when :sns, "sns"
+        require_relative "transport/sns"
+        Transport::Sns.new(configuration: configuration, logger: logger)
+      when :slack, "slack", nil
+        require_relative "transport/slack"
+        Transport::Slack.new(configuration: configuration, logger: logger)
+      else
+        if configuration.transport_adapter.is_a?(Class)
+          configuration.transport_adapter.new(configuration: configuration, logger: logger)
+        elsif configuration.transport_adapter.respond_to?(:new)
+          configuration.transport_adapter.new(configuration: configuration, logger: logger)
+        else
+          raise ArgumentError, "Invalid transport adapter: #{configuration.transport_adapter}"
+        end
       end
     end
-
-    def valid_configuration?
-      return false unless Newshound.configuration.valid?
-      
-      webhook_configured? || web_api_configured?
-    end
-
-    def webhook_configured?
-      Newshound.configuration.slack_webhook_url.present?
-    end
-
-    def web_api_configured?
-      ENV["SLACK_API_TOKEN"].present?
-    end
-
-    def post_via_webhook(message)
-      client = Slack::Incoming::Webhook.new(Newshound.configuration.slack_webhook_url)
-      client.post(message)
-    end
-
-    def post_via_web_api(message)
-      client = Slack::Web::Client.new
-      client.chat_postMessage(
-        channel: Newshound.configuration.slack_channel,
-        blocks: message[:blocks],
-        text: "Daily Newshound Report"
-      )
-    end
   end
 end

data/lib/newshound/transport/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Newshound
+  module Transport
+    class Base
+      attr_reader :configuration, :logger
+
+      def initialize(configuration: nil, logger: nil)
+        @configuration = configuration || Newshound.configuration
+        @logger = logger || default_logger
+      end
+
+      def deliver(message)
+        raise NotImplementedError, "Subclasses must implement the #deliver method"
+      end
+
+      protected
+
+      def default_logger
+        if defined?(Rails)
+          Rails.logger
+        else
+          Logger.new(STDOUT)
+        end
+      end
+    end
+  end
+end

data/lib/newshound/transport/slack.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "slack-ruby-client"
+require_relative "base"
+
+module Newshound
+  module Transport
+    class Slack < Base
+      attr_reader :webhook_client, :web_api_client
+
+      def initialize(configuration: nil, logger: nil, webhook_client: nil, web_api_client: nil)
+        super(configuration: configuration, logger: logger)
+        @webhook_client = webhook_client
+        @web_api_client = web_api_client
+        configure_slack_client
+      end
+
+      def deliver(message)
+        return unless configuration.valid?
+
+        if webhook_configured?
+          deliver_via_webhook(message)
+        elsif web_api_configured?
+          deliver_via_web_api(message)
+        else
+          logger.error "Newshound: No valid Slack configuration found"
+          false
+        end
+      rescue StandardError => e
+        logger.error "Newshound: Failed to send Slack notification: #{e.message}"
+        false
+      end
+
+      private
+
+      def configure_slack_client
+        ::Slack.configure do |config|
+          config.token = ENV["SLACK_API_TOKEN"] if ENV["SLACK_API_TOKEN"]
+        end
+      end
+
+      def webhook_configured?
+        !configuration.slack_webhook_url.nil? && !configuration.slack_webhook_url.empty?
+      end
+
+      def web_api_configured?
+        !ENV["SLACK_API_TOKEN"].nil? && !ENV["SLACK_API_TOKEN"].empty?
+      end
+
+      def deliver_via_webhook(message)
+        client = webhook_client || ::Slack::Incoming::Webhook.new(configuration.slack_webhook_url)
+        client.post(message)
+        true
+      end
+
+      def deliver_via_web_api(message)
+        client = web_api_client || ::Slack::Web::Client.new
+        client.chat_postMessage(
+          channel: configuration.slack_channel,
+          blocks: message[:blocks],
+          text: "Daily Newshound Report"
+        )
+        true
+      end
+    end
+  end
+end

data/lib/newshound/transport/sns.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Newshound
+  module Transport
+    class Sns < Base
+      attr_reader :sns_client
+
+      def initialize(configuration: nil, logger: nil, sns_client: nil)
+        super(configuration: configuration, logger: logger)
+        @sns_client = sns_client || build_sns_client
+      end
+
+      def deliver(message)
+        return false unless valid_sns_configuration?
+
+        formatted_message = format_message(message)
+
+        response = sns_client.publish(
+          topic_arn: configuration.sns_topic_arn,
+          message: formatted_message,
+          subject: extract_subject(message)
+        )
+
+        logger.info "Newshound: Message sent to SNS, MessageId: #{response.message_id}"
+        true
+      rescue StandardError => e
+        logger.error "Newshound: Failed to send SNS notification: #{e.message}"
+        false
+      end
+
+      private
+
+      def build_sns_client
+        require "aws-sdk-sns"
+
+        options = {
+          region: configuration.aws_region || ENV["AWS_REGION"] || "us-east-1"
+        }
+
+        if configuration.aws_access_key_id && configuration.aws_secret_access_key
+          options[:credentials] = Aws::Credentials.new(
+            configuration.aws_access_key_id,
+            configuration.aws_secret_access_key
+          )
+        end
+
+        Aws::SNS::Client.new(options)
+      end
+
+      def valid_sns_configuration?
+        if configuration.sns_topic_arn.nil? || configuration.sns_topic_arn.empty?
+          logger.error "Newshound: SNS topic ARN not configured"
+          false
+        else
+          true
+        end
+      end
+
+      def format_message(message)
+        case message
+        when Hash
+          if message[:blocks]
+            format_slack_blocks_for_sns(message[:blocks])
+          else
+            JSON.pretty_generate(message)
+          end
+        when String
+          message
+        else
+          message.to_s
+        end
+      end
+
+      def format_slack_blocks_for_sns(blocks)
+        lines = []
+
+        blocks.each do |block|
+          case block[:type]
+          when "section"
+            if block[:text]
+              lines << format_text_element(block[:text])
+            end
+          when "header"
+            if block[:text]
+              lines << "=== #{format_text_element(block[:text])} ==="
+            end
+          when "divider"
+            lines << "---"
+          end
+        end
+
+        lines.join("\n\n")
+      end
+
+      def format_text_element(text_element)
+        return "" unless text_element
+
+        text = text_element[:text] || ""
+        text.gsub(/:([a-z_]+):/, '')
+            .gsub(/\*(.+?)\*/, '\1')
+            .gsub(/_(.+?)_/, '\1')
+      end
+
+      def extract_subject(message)
+        if message.is_a?(Hash)
+          message[:subject] || "Newshound Notification"
+        else
+          "Newshound Notification"
+        end
+      end
+    end
+  end
+end

data/lib/newshound/version.rb

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

data/newshound.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/newshound/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "newshound"
+  spec.version = Newshound::VERSION
+  spec.authors = ["salbanez"]
+  spec.email = ["salbanez@example.com"]
+
+  spec.summary = "Daily Slack reporter for Que jobs status and exception tracking"
+  spec.description = "Newshound sniffs out exceptions and job statuses in your Rails app and reports them daily to Slack"
+  spec.homepage = "https://github.com/salbanez/newshound"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "rails", ">= 6.0"
+  spec.add_dependency "slack-ruby-client", "~> 2.0"
+  spec.add_dependency "que", ">= 1.0"
+  spec.add_dependency "que-scheduler", ">= 4.0"
+  spec.add_dependency "exception-track", ">= 0.1"
+
+  # Optional dependency for SNS transport
+  spec.add_development_dependency "aws-sdk-sns", "~> 1.0"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newshound
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - salbanez
@@ -80,49 +80,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
+  name: aws-sdk-sns
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -135,20 +93,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Newshound sniffs out exceptions and job statuses in your Rails app and
   reports them daily to Slack
 email:
@@ -157,9 +101,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
+- ".tool-versions"
 - Gemfile
 - README.md
 - Rakefile
+- TRANSPORT_USAGE.md
+- lib/generators/newshound/install/install_generator.rb
+- lib/generators/newshound/install/templates/newshound.rb
 - lib/newshound.rb
 - lib/newshound/configuration.rb
 - lib/newshound/daily_report_job.rb
@@ -168,7 +117,11 @@ files:
 - lib/newshound/railtie.rb
 - lib/newshound/scheduler.rb
 - lib/newshound/slack_notifier.rb
+- lib/newshound/transport/base.rb
+- lib/newshound/transport/slack.rb
+- lib/newshound/transport/sns.rb
 - lib/newshound/version.rb
+- newshound.gemspec
 homepage: https://github.com/salbanez/newshound
 licenses:
 - MIT