actionwebpush 0.1.0

data/lib/actionwebpush/pool.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+require "net/http/persistent"
+
+module ActionWebPush
+  class Pool
+    include ActionWebPush::Logging
+    attr_reader :delivery_pool, :invalidation_pool, :connection, :invalid_subscription_handler
+    attr_accessor :overflow_count, :total_queued_count
+
+    def initialize(invalid_subscription_handler: nil)
+      config = ActionWebPush.config
+
+      @delivery_pool = Concurrent::ThreadPoolExecutor.new(
+        max_threads: config.pool_size,
+        queue_size: config.queue_size
+      )
+      @invalidation_pool = Concurrent::FixedThreadPool.new(1)
+      @connection = Net::HTTP::Persistent.new(name: "action_web_push", pool_size: config.connection_pool_size)
+      @invalid_subscription_handler = invalid_subscription_handler
+
+      # Initialize metrics
+      @overflow_count = 0
+      @total_queued_count = 0
+      @overflow_mutex = Mutex.new
+    end
+
+    def queue(notifications, subscriptions = nil)
+      if subscriptions
+        # Multiple subscriptions with same notification data
+        subscriptions.find_each do |subscription|
+          notification = subscription.build_notification(notifications)
+          deliver_later(notification, subscription.id)
+        end
+      elsif notifications.is_a?(Array)
+        # Array of notifications
+        notifications.each { |notification| deliver_later(notification) }
+      else
+        # Single notification
+        deliver_later(notifications)
+      end
+    end
+
+    def shutdown
+      connection.shutdown
+      shutdown_pool(delivery_pool)
+      shutdown_pool(invalidation_pool)
+      log_final_metrics
+    end
+
+    def metrics
+      @overflow_mutex.synchronize do
+        {
+          total_queued: @total_queued_count,
+          overflow_count: @overflow_count,
+          overflow_rate: @total_queued_count > 0 ? (@overflow_count.to_f / @total_queued_count * 100).round(2) : 0.0,
+          pool_queue_size: delivery_pool.queue_length,
+          pool_active_threads: delivery_pool.length,
+          pool_max_threads: delivery_pool.max_length
+        }
+      end
+    end
+
+    private
+
+    def deliver_later(notification, subscription_id = nil)
+      @overflow_mutex.synchronize { @total_queued_count += 1 }
+
+      delivery_pool.post do
+        deliver(notification, subscription_id)
+      rescue Exception => e
+        logger.error "Error in ActionWebPush::Pool.deliver: #{e.class} #{e.message}"
+      end
+    rescue Concurrent::RejectedExecutionError
+      handle_queue_overflow(notification, subscription_id)
+    end
+
+    def deliver(notification, subscription_id = nil)
+      notification.deliver(connection: connection)
+    rescue ActionWebPush::ExpiredSubscriptionError => e
+      context = {
+        endpoint: notification.respond_to?(:endpoint) ? notification.endpoint : nil,
+        subscription_id: subscription_id
+      }
+      ActionWebPush::ErrorHandler.handle_expired_subscription_error(e, context)
+      invalidate_subscription_later(subscription_id) if subscription_id && invalid_subscription_handler
+    rescue ActionWebPush::RateLimitExceeded => e
+      context = {
+        resource_type: :endpoint,
+        resource_id: notification.respond_to?(:endpoint) ? notification.endpoint : nil
+      }
+      ActionWebPush::ErrorHandler.handle_rate_limit_error(e, context)
+      raise e
+    rescue ActionWebPush::DeliveryError => e
+      context = {
+        endpoint: notification.respond_to?(:endpoint) ? notification.endpoint : nil,
+        title: notification.respond_to?(:title) ? notification.title : nil,
+        retry_count: 0
+      }
+      ActionWebPush::ErrorHandler.handle_delivery_failure(e, context)
+      raise e
+    rescue WebPush::ExpiredSubscription, OpenSSL::OpenSSLError => e
+      # Handle legacy WebPush exceptions
+      context = {
+        endpoint: notification.respond_to?(:endpoint) ? notification.endpoint : nil,
+        subscription_id: subscription_id
+      }
+      error = ActionWebPush::ExpiredSubscriptionError.new(e.message)
+      ActionWebPush::ErrorHandler.handle_expired_subscription_error(error, context)
+      invalidate_subscription_later(subscription_id) if subscription_id && invalid_subscription_handler
+    rescue StandardError => e
+      context = {
+        endpoint: notification.respond_to?(:endpoint) ? notification.endpoint : nil,
+        title: notification.respond_to?(:title) ? notification.title : nil
+      }
+      handled_error = ActionWebPush::ErrorHandler.handle_unexpected_error(e, context)
+      raise handled_error
+    end
+
+    def invalidate_subscription_later(subscription_id)
+      invalidation_pool.post do
+        invalid_subscription_handler.call(subscription_id)
+      rescue Exception => e
+        logger.error "Error in ActionWebPush::Pool.invalid_subscription_handler: #{e.class} #{e.message}"
+      end
+    end
+
+    def handle_queue_overflow(notification, subscription_id = nil)
+      @overflow_mutex.synchronize { @overflow_count += 1 }
+
+      overflow_rate = @overflow_mutex.synchronize { (@overflow_count.to_f / @total_queued_count * 100).round(2) }
+
+      # Instrument the overflow event
+      ActionWebPush::Instrumentation.publish("pool_overflow",
+        overflow_count: @overflow_count,
+        total_queued: @total_queued_count,
+        overflow_rate: overflow_rate,
+        queue_length: delivery_pool.queue_length,
+        active_threads: delivery_pool.length,
+        max_threads: delivery_pool.max_length,
+        notification_title: notification.respond_to?(:title) ? notification.title : nil
+      )
+
+      logger.warn "ActionWebPush::Pool queue overflow (#{@overflow_count}/#{@total_queued_count}, #{overflow_rate}%): dropping notification"
+
+      # Log additional context for debugging
+      logger.warn "Pool stats: queue=#{delivery_pool.queue_length}, active=#{delivery_pool.length}/#{delivery_pool.max_length}"
+
+      # TODO: Could implement fallback strategies here:
+      # - Store in Redis for retry
+      # - Send to DLQ
+      # - Immediate synchronous delivery for critical notifications
+    end
+
+    def log_final_metrics
+      stats = metrics
+      logger.info "ActionWebPush::Pool shutdown metrics: #{stats}"
+    end
+
+    def shutdown_pool(pool)
+      pool.shutdown
+      pool.kill unless pool.wait_for_termination(1)
+    end
+
+  end
+end

data/lib/actionwebpush/railtie.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ActionWebPush
+  class Railtie < ::Rails::Railtie
+    config.action_web_push = ActiveSupport::OrderedOptions.new
+
+    initializer "action_web_push.set_configs" do |app|
+      options = app.config.action_web_push
+
+      ActionWebPush.configure do |config|
+        config.vapid_public_key = options.vapid_public_key if options.vapid_public_key
+        config.vapid_private_key = options.vapid_private_key if options.vapid_private_key
+        config.vapid_subject = options.vapid_subject if options.vapid_subject
+        config.pool_size = options.pool_size if options.pool_size
+        config.queue_size = options.queue_size if options.queue_size
+        config.delivery_method = options.delivery_method if options.delivery_method
+      end
+    end
+
+    initializer "action_web_push.initialize_pool" do |app|
+      app.config.x.action_web_push_pool = ActionWebPush::Pool.new(
+        invalid_subscription_handler: ->(subscription_id) do
+          Rails.application.executor.wrap do
+            Rails.logger.info "Destroying push subscription: #{subscription_id}"
+            ActionWebPush::Subscription.find_by(id: subscription_id)&.destroy
+          end
+        end
+      )
+
+      at_exit { app.config.x.action_web_push_pool.shutdown }
+    end
+
+    initializer "action_web_push.set_autoload_paths" do |app|
+      models_path = File.expand_path("../../app/models", __dir__)
+      controllers_path = File.expand_path("../../app/controllers", __dir__)
+
+      unless app.config.autoload_paths.include?(models_path)
+        app.config.autoload_paths += [models_path]
+      end
+
+      unless app.config.autoload_paths.include?(controllers_path)
+        app.config.autoload_paths += [controllers_path]
+      end
+    end
+  end
+end

data/lib/actionwebpush/rate_limiter.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "redis" if defined?(Redis)
+
+module ActionWebPush
+  class RateLimiter
+    class MemoryStore
+      CLEANUP_INTERVAL = 300 # 5 minutes
+
+      def initialize
+        @store = {}
+        @mutex = Mutex.new
+        @last_cleanup = Time.now
+      end
+
+      def increment(key, ttl)
+        @mutex.synchronize do
+          # Periodic automatic cleanup
+          auto_cleanup! if should_cleanup?
+
+          @store[key] ||= { count: 0, expires_at: Time.now + ttl }
+
+          if @store[key][:expires_at] < Time.now
+            @store[key] = { count: 1, expires_at: Time.now + ttl }
+          else
+            @store[key][:count] += 1
+          end
+
+          @store[key][:count]
+        end
+      end
+
+      def cleanup!
+        @mutex.synchronize do
+          auto_cleanup!
+        end
+      end
+
+      def get(key)
+        @mutex.synchronize do
+          entry = @store[key]
+          return 0 unless entry
+          return 0 if entry[:expires_at] < Time.now
+          entry[:count]
+        end
+      end
+
+      def size
+        @mutex.synchronize { @store.size }
+      end
+
+      private
+
+      def should_cleanup?
+        Time.now - @last_cleanup > CLEANUP_INTERVAL
+      end
+
+      def auto_cleanup!
+        before_count = @store.size
+        @store.reject! { |_, v| v[:expires_at] < Time.now }
+        @last_cleanup = Time.now
+
+        # Log significant cleanups
+        cleaned = before_count - @store.size
+        if cleaned > 0 && defined?(ActionWebPush) && ActionWebPush.respond_to?(:logger)
+          ActionWebPush.logger.debug "ActionWebPush::RateLimiter cleaned up #{cleaned} expired entries (#{@store.size} remaining)"
+        end
+      end
+    end
+
+    class RedisStore
+      def initialize(redis_client = nil)
+        @redis = redis_client || Redis.current
+      end
+
+      def increment(key, ttl)
+        result = @redis.multi do |multi|
+          multi.incr(key)
+          multi.expire(key, ttl.to_i)
+        end
+        result[0]
+      end
+
+      def get(key)
+        value = @redis.get(key)
+        value ? value.to_i : 0
+      end
+    end
+
+    attr_reader :store, :limits
+
+    def initialize(store: nil, limits: {})
+      @store = store || (defined?(Redis) ? RedisStore.new : MemoryStore.new)
+      @limits = default_limits.merge(limits)
+    end
+
+    def check_rate_limit!(resource_type, resource_id, user_id = nil)
+      limit_key = rate_limit_key(resource_type, resource_id, user_id)
+      limit_config = limits[resource_type]
+
+      return true unless limit_config
+
+      current_count = store.increment(limit_key, limit_config[:window])
+
+      if current_count > limit_config[:max_requests]
+        # Instrument rate limit exceeded event
+        ActionWebPush::Instrumentation.publish("rate_limit_exceeded",
+          resource_type: resource_type,
+          resource_id: resource_id,
+          user_id: user_id,
+          current_count: current_count,
+          max_requests: limit_config[:max_requests],
+          window: limit_config[:window]
+        )
+
+        raise ActionWebPush::RateLimitExceeded,
+              "Rate limit exceeded for #{resource_type}: #{current_count}/#{limit_config[:max_requests]} in #{limit_config[:window]}s"
+      end
+
+      true
+    end
+
+    def within_rate_limit?(resource_type, resource_id, user_id = nil)
+      check_rate_limit!(resource_type, resource_id, user_id)
+      true
+    rescue ActionWebPush::RateLimitExceeded
+      false
+    end
+
+    def rate_limit_info(resource_type, resource_id, user_id = nil)
+      limit_key = rate_limit_key(resource_type, resource_id, user_id)
+      limit_config = limits[resource_type]
+
+      return nil unless limit_config
+
+      # Use atomic read-only get instead of increment-subtract
+      current_count = store.get(limit_key)
+
+      {
+        limit: limit_config[:max_requests],
+        remaining: [limit_config[:max_requests] - current_count, 0].max,
+        window: limit_config[:window],
+        reset_at: Time.now + limit_config[:window]
+      }
+    end
+
+    private
+
+    def default_limits
+      {
+        endpoint: { max_requests: 100, window: 3600 },      # 100 per hour per endpoint
+        user: { max_requests: 1000, window: 3600 },        # 1000 per hour per user
+        global: { max_requests: 10000, window: 3600 },     # 10k per hour globally
+        subscription: { max_requests: 50, window: 3600 }   # 50 per hour per subscription
+      }
+    end
+
+    def rate_limit_key(resource_type, resource_id, user_id = nil)
+      parts = ["action_web_push", "rate_limit", resource_type.to_s]
+      parts << "user_#{user_id}" if user_id
+      parts << resource_id.to_s
+      parts.join(":")
+    end
+  end
+
+  class RateLimitExceeded < Error; end
+end

data/lib/actionwebpush/sentry_integration.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class SentryIntegration
+    class << self
+      def configure
+        return unless defined?(Sentry)
+
+        Sentry.configure_scope do |scope|
+          scope.set_tag("component", "action_web_push")
+        end
+      end
+
+      def capture_delivery_error(notification, error, context = {})
+        return unless defined?(Sentry)
+
+        Sentry.with_scope do |scope|
+          scope.set_tag("action_web_push_event", "delivery_error")
+          scope.set_context("notification", notification_context(notification))
+          scope.set_context("delivery_context", context)
+
+          if error.is_a?(ActionWebPush::ExpiredSubscriptionError)
+            scope.set_level(:info)
+            scope.set_tag("error_type", "expired_subscription")
+          elsif error.is_a?(ActionWebPush::RateLimitExceeded)
+            scope.set_level(:warning)
+            scope.set_tag("error_type", "rate_limit_exceeded")
+          else
+            scope.set_level(:error)
+            scope.set_tag("error_type", "delivery_failure")
+          end
+
+          Sentry.capture_exception(error)
+        end
+      end
+
+      def capture_performance_metrics(metrics)
+        return unless defined?(Sentry)
+
+        Sentry.with_scope do |scope|
+          scope.set_tag("action_web_push_event", "performance_metrics")
+          scope.set_context("metrics", metrics)
+
+          if metrics[:success_rate] < 95.0
+            Sentry.capture_message(
+              "ActionWebPush success rate below threshold: #{metrics[:success_rate]}%",
+              level: :warning
+            )
+          end
+        end
+      end
+
+      def capture_subscription_event(event_type, subscription, details = {})
+        return unless defined?(Sentry)
+
+        Sentry.with_scope do |scope|
+          scope.set_tag("action_web_push_event", event_type.to_s)
+          scope.set_context("subscription", subscription_context(subscription))
+          scope.set_context("event_details", details)
+
+          case event_type
+          when :expired
+            scope.set_level(:info)
+            Sentry.capture_message("Push subscription expired", level: :info)
+          when :created
+            scope.set_level(:info)
+            Sentry.capture_message("Push subscription created", level: :info)
+          when :bulk_cleanup
+            scope.set_level(:info)
+            Sentry.capture_message("Bulk subscription cleanup performed", level: :info)
+          end
+        end
+      end
+
+      private
+
+      def notification_context(notification)
+        {
+          title: notification.title&.truncate(100),
+          endpoint_domain: extract_domain(notification.endpoint),
+          has_data: notification.data.present?,
+          options_keys: notification.options.keys
+        }
+      end
+
+      def subscription_context(subscription)
+        {
+          id: subscription.id,
+          endpoint_domain: extract_domain(subscription.endpoint),
+          user_agent: subscription.user_agent&.truncate(100),
+          created_at: subscription.created_at,
+          updated_at: subscription.updated_at,
+          active: subscription.active?
+        }
+      end
+
+      def extract_domain(endpoint)
+        URI.parse(endpoint).host
+      rescue StandardError
+        "unknown"
+      end
+    end
+  end
+end

data/lib/actionwebpush/status_broadcaster.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class StatusBroadcaster
+    class << self
+      def broadcast_delivery_status(user_id, notification_id, status, details = {})
+        return unless defined?(ActionCable)
+
+        ActionCable.server.broadcast(
+          "action_web_push_status_#{user_id}",
+          {
+            type: "delivery_status",
+            notification_id: notification_id,
+            status: status,
+            timestamp: Time.current.iso8601,
+            details: details
+          }
+        )
+      end
+
+      def broadcast_delivery_attempt(user_id, notification_id, subscription_count)
+        broadcast_delivery_status(
+          user_id,
+          notification_id,
+          "attempting",
+          { subscription_count: subscription_count }
+        )
+      end
+
+      def broadcast_delivery_success(user_id, notification_id, delivered_count)
+        broadcast_delivery_status(
+          user_id,
+          notification_id,
+          "delivered",
+          { delivered_count: delivered_count }
+        )
+      end
+
+      def broadcast_delivery_failure(user_id, notification_id, error_message, failed_count = 1)
+        broadcast_delivery_status(
+          user_id,
+          notification_id,
+          "failed",
+          { error: error_message, failed_count: failed_count }
+        )
+      end
+
+      def broadcast_subscription_expired(user_id, subscription_id)
+        return unless defined?(ActionCable)
+
+        ActionCable.server.broadcast(
+          "action_web_push_status_#{user_id}",
+          {
+            type: "subscription_expired",
+            subscription_id: subscription_id,
+            timestamp: Time.current.iso8601
+          }
+        )
+      end
+    end
+  end
+end

data/lib/actionwebpush/status_channel.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class StatusChannel < ActionCable::Channel::Base
+    def subscribed
+      stream_from "action_web_push_status_#{current_user&.id}" if current_user
+    end
+
+    def unsubscribed
+      # Cleanup when channel is unsubscribed
+    end
+
+    private
+
+    def current_user
+      # This should be implemented based on your authentication system
+      # Example: connection.current_user
+      nil
+    end
+  end
+end

data/lib/actionwebpush/tenant_configuration.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class TenantConfiguration
+    attr_accessor :tenant_id, :vapid_public_key, :vapid_private_key, :vapid_subject
+    attr_accessor :pool_size, :queue_size, :delivery_method, :rate_limits
+    attr_accessor :webhook_url, :custom_settings
+
+    def initialize(tenant_id, **options)
+      @tenant_id = tenant_id
+      @vapid_public_key = options[:vapid_public_key]
+      @vapid_private_key = options[:vapid_private_key]
+      @vapid_subject = options[:vapid_subject] || "mailto:support@example.com"
+      @pool_size = options[:pool_size] || 50
+      @queue_size = options[:queue_size] || 10000
+      @delivery_method = options[:delivery_method] || :web_push
+      @rate_limits = options[:rate_limits] || {}
+      @webhook_url = options[:webhook_url]
+      @custom_settings = options[:custom_settings] || {}
+    end
+
+    def valid?
+      vapid_public_key.present? && vapid_private_key.present?
+    end
+
+    def vapid_keys
+      {
+        public_key: vapid_public_key,
+        private_key: vapid_private_key,
+        subject: vapid_subject
+      }
+    end
+
+    def to_h
+      {
+        tenant_id: tenant_id,
+        vapid_public_key: vapid_public_key,
+        vapid_private_key: vapid_private_key,
+        vapid_subject: vapid_subject,
+        pool_size: pool_size,
+        queue_size: queue_size,
+        delivery_method: delivery_method,
+        rate_limits: rate_limits,
+        webhook_url: webhook_url,
+        custom_settings: custom_settings
+      }
+    end
+  end
+
+  class TenantManager
+    class << self
+      attr_accessor :configurations
+
+      def configure_tenant(tenant_id, **options)
+        self.configurations ||= {}
+        configurations[tenant_id] = TenantConfiguration.new(tenant_id, **options)
+      end
+
+      def configuration_for(tenant_id)
+        configurations&.[](tenant_id) || raise(ConfigurationError, "No configuration found for tenant: #{tenant_id}")
+      end
+
+      def tenant_exists?(tenant_id)
+        configurations&.key?(tenant_id) || false
+      end
+
+      def all_tenants
+        configurations&.keys || []
+      end
+
+      def reset!
+        self.configurations = {}
+      end
+    end
+  end
+
+  module TenantAware
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :tenant_column, default: :tenant_id
+
+      scope :for_tenant, ->(tenant_id) { where(tenant_column => tenant_id) }
+
+      before_validation :set_tenant_id, if: :should_set_tenant_id?
+    end
+
+    class_methods do
+      def tenant_aware(column: :tenant_id)
+        self.tenant_column = column
+      end
+    end
+
+    private
+
+    def should_set_tenant_id?
+      respond_to?(tenant_column) &&
+        public_send(tenant_column).blank? &&
+        ActionWebPush.current_tenant_id.present?
+    end
+
+    def set_tenant_id
+      public_send("#{tenant_column}=", ActionWebPush.current_tenant_id)
+    end
+  end
+end