actionmcp 0.32.1 → 0.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54b807ad23c23796ef5495fb91afffb9ee10d998516a72d20897c519bed56c4c
-  data.tar.gz: e5ec996f8e8dcb73383de34fe5f851382961a74a27e3b28c26271aadb343c30f
+  metadata.gz: 845438ee87dd1b7c0453604f5716981ab1ac345a3413b135237aa82d6329cdd3
+  data.tar.gz: 0a8666f43de743705899d20a784de5796d9be421619f736db067d3143f38a495
 SHA512:
-  metadata.gz: 55938823b5df5d13b8ffe2adbb9e581331e60fabb2f7111807fa10b119cd898f2ab3dd695cbda8924af0b9be79cf9eb0767b18324a1042ac46fb4facb6562abe
-  data.tar.gz: 76c6c5a553e55f06b61165844a3d55e45854dffe515879f14eaaf5b1399aa8f3273563b3c78cf028bab54547cc3165947cd5e2606e19f96be55285c845c641ef
+  metadata.gz: fdeb2ef3b774d957a812cf1a82ee5135ddacb352746c83ef45aacd3bcf715b900467d7d6154b83b0a2024aa611671102addf4ab97884d43b928c89d7c78f68ac
+  data.tar.gz: 8ad56c0ff5a39e299d4133e39b5eae5acffaf24c6f07bd49c5f33a40afe71d6e158bf3d071ee28a4926ecf1f189e4b91d60bd76bf8d91088c9f68be4b4eeb93a

data/README.md

@@ -1,6 +1,10 @@
 # ActionMCP
 
-**ActionMCP** is a Ruby gem that provides essential tooling for building Model Context Protocol (MCP) capable servers in Ruby on Rails applications.
+**ActionMCP** is a Ruby gem focused on providing Model Context Protocol (MCP) capability to Ruby on Rails applications, specifically as a server.
+
+ActionMCP is designed for production Rails environments and does **not** support STDIO transport. STDIO is not included because it is not production-ready and is only suitable for desktop or script-based use cases. Instead, ActionMCP is built for robust, network-based deployments.
+
+The client functionality in ActionMCP is intended to connect to remote MCP servers, not to local processes via STDIO.
 
 It offers base classes and helpers for creating MCP applications, making it easier to integrate your Ruby/Rails application with the MCP standard.
 
@@ -16,8 +20,9 @@ MCP allows AI systems to plug into various resources in a consistent, secure way
 
 This means an AI (like an LLM) can request information or actions from your application through a well-defined protocol, and your app can provide context or perform tasks for the AI in return.
 
-**ActionMCP** is targeted at developers building MCP-enabled applications.
-It simplifies the process of integrating Ruby and Rails apps with the MCP standard by providing a set of base classes and an easy-to-use server interface.
+**ActionMCP** is targeted at developers building MCP-enabled Rails applications. It simplifies the process of integrating Ruby and Rails apps with the MCP standard by providing a set of base classes and an easy-to-use server interface.
+
+> **Note:** STDIO transport is not supported in ActionMCP. This gem is focused on production-ready, network-based deployments. STDIO is only suitable for desktop or script-based experimentation and is intentionally excluded.
 
 Instead of implementing MCP support from scratch, you can subclass and configure the provided **Prompt**, **Tool**, and **ResourceTemplate** classes to expose your app's functionality to LLMs. 
 
@@ -25,6 +30,8 @@ ActionMCP handles the underlying MCP message format and routing, so you can adhe
 
 In short, ActionMCP helps you build an MCP server (the component that exposes capabilities to AI) more quickly and with fewer mistakes.
 
+> **Client connections:** The client part of ActionMCP is meant to connect to remote MCP servers only. Connecting to local processes (such as via STDIO) is not supported.
+
 ## Installation
 
 To start using ActionMCP, add it to your project:
@@ -221,9 +228,136 @@ end
 
 For dynamic versioning, consider adding the `rails_app_version` gem.
 
+### PubSub Configuration
+
+ActionMCP uses a pub/sub system for real-time communication. You can choose between several adapters:
+
+1. **SolidCable** - Database-backed pub/sub (no Redis required)
+2. **Simple** - In-memory pub/sub for development and testing
+3. **Redis** - Redis-backed pub/sub (if you prefer Redis)
+
+#### Migrating from ActionCable
+
+If you were previously using ActionCable with ActionMCP, you will need to migrate to the new PubSub system. Here's how:
+
+1. Remove the ActionCable dependency from your Gemfile (if you don't need it for other purposes)
+2. Install one of the PubSub adapters (SolidCable recommended)
+3. Create a configuration file at `config/mcp.yml` (you can use the generator: `bin/rails g action_mcp:config`)
+4. Run your tests to ensure everything works correctly
+
+The new PubSub system maintains the same API as the previous ActionCable-based implementation, so your existing code should continue to work without changes.
+
+Configure your adapter in `config/mcp.yml`:
+
+```yaml
+development:
+  adapter: solid_cable
+  polling_interval: 0.1.seconds
+  # Thread pool configuration (optional)
+  # min_threads: 5     # Minimum number of threads in the pool
+  # max_threads: 10    # Maximum number of threads in the pool
+  # max_queue: 100     # Maximum number of tasks that can be queued
+
+test:
+  adapter: test    # Uses the simple in-memory adapter
+
+production:
+  adapter: solid_cable
+  polling_interval: 0.5.seconds
+  # Optional: connects_to: cable  # If using a separate database
+  
+  # Thread pool configuration for high-traffic environments
+  min_threads: 10     # Minimum number of threads in the pool
+  max_threads: 20     # Maximum number of threads in the pool
+  max_queue: 500      # Maximum number of tasks that can be queued
+```
+
+#### SolidCable (Database-backed, Recommended)
+
+For SolidCable, add it to your Gemfile:
+
+```ruby
+gem "solid_cable"  # Database-backed adapter (no Redis needed)
+```
+
+Then install it:
+
+```bash
+bundle install
+bin/rails solid_cable:install
+```
+
+The installer will create the necessary database migration. You'll need to configure it in your `config/mcp.yml`. You can create this file with `bin/rails g action_mcp:config`.
+
+#### Redis Adapter
+
+If you prefer Redis, add it to your Gemfile:
+
+```ruby
+gem "redis", "~> 5.0"
+```
+
+Then configure the Redis adapter in your `config/mcp.yml`:
+
+```yaml
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: your_app_production
+  
+  # Thread pool configuration for high-traffic environments
+  min_threads: 10     # Minimum number of threads in the pool
+  max_threads: 20     # Maximum number of threads in the pool
+  max_queue: 500      # Maximum number of tasks that can be queued
+```
+
+## Thread Pool Management
+
+ActionMCP uses thread pools to efficiently handle message callbacks. This prevents the system from being overwhelmed by too many threads under high load.
+
+### Thread Pool Configuration
+
+You can configure the thread pool in your `config/mcp.yml`:
+
+```yaml
+production:
+  adapter: solid_cable
+  # Thread pool configuration
+  min_threads: 10    # Minimum number of threads to keep in the pool
+  max_threads: 20    # Maximum number of threads the pool can grow to
+  max_queue: 500     # Maximum number of tasks that can be queued
+```
+
+The thread pool will automatically:
+- Start with `min_threads` threads
+- Scale up to `max_threads` as needed
+- Queue tasks up to `max_queue` limit
+- Use caller's thread if queue is full (fallback policy)
+
+### Graceful Shutdown
+
+When your application is shutting down, you should call:
+
+```ruby
+ActionMCP::Server.shutdown
+```
+
+This ensures all thread pools are properly terminated and tasks are completed.
+
 ## Engine and Mounting
 
-**ActionMCP** runs as a standalone Rack application, similar to **ActionCable**. It is **not** mounted in `routes.rb`.
+**ActionMCP** runs as a standalone Rack application. It is **not** mounted in `routes.rb`.
+
+### Installing the Configuration Generator
+
+ActionMCP includes a generator to help you create the configuration file:
+
+```bash
+# Generate the mcp.yml configuration file
+bin/rails generate action_mcp:config
+```
+
+This will create `config/mcp.yml` with example configurations for all environments.
 
 > **Note:** Authentication and authorization are not included. You are responsible for securing the endpoint.
 

data/app/controllers/action_mcp/unified_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  # Handles the unified MCP endpoint for the 2025-03-26 specification.
+  # Implements the MCP endpoints according to the 2025-03-26 specification.
   # Supports GET for server-initiated SSE streams, POST for client messages
   # (responding with JSON or SSE), and optionally DELETE for session termination.
   class UnifiedController < MCPController

data/config/routes.rb

@@ -2,14 +2,9 @@
 
 ActionMCP::Engine.routes.draw do
   get "/up", to: "/rails/health#show", as: :action_mcp_health_check
-  # --- Routes for 2024-11-05 Spec (HTTP+SSE) ---
-  # Kept for backward compatibility
-  get "/", to: "sse#events", as: :sse_out
-  post "/", to: "messages#create", as: :sse_in, defaults: { format: "json" }
 
-  # --- Routes for 2025-03-26 Spec (Streamable HTTP) ---
-  mcp_endpoint = ActionMCP.configuration.mcp_endpoint_path
-  get mcp_endpoint, to: "unified#show", as: :mcp_get
-  post mcp_endpoint, to: "unified#create", as: :mcp_post
-  delete mcp_endpoint, to: "unified#destroy", as: :mcp_delete
+  # MCP 2025-03-26 Spec routes
+  get "/", to: "unified#show", as: :mcp_get
+  post "/", to: "unified#create", as: :mcp_post
+  delete "/", to: "unified#destroy", as: :mcp_delete
 end

data/db/migrate/20250512154359_consolidated_migration.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+class ConsolidatedMigration < ActiveRecord::Migration[8.0]
+  def change
+    # Only create tables if they don't exist to avoid deleting existing data
+
+    # Create sessions table
+    unless table_exists?(:action_mcp_sessions)
+      create_table :action_mcp_sessions, id: :string do |t|
+        t.string :role, null: false, default: 'server', comment: 'The role of the session'
+        t.string :status, null: false, default: 'pre_initialize'
+        t.datetime :ended_at, comment: 'The time the session ended'
+        t.string :protocol_version
+        t.jsonb :server_capabilities, comment: 'The capabilities of the server'
+        t.jsonb :client_capabilities, comment: 'The capabilities of the client'
+        t.jsonb :server_info, comment: 'The information about the server'
+        t.jsonb :client_info, comment: 'The information about the client'
+        t.boolean :initialized, null: false, default: false
+        t.integer :messages_count, null: false, default: 0
+        t.integer :sse_event_counter, default: 0, null: false
+        t.jsonb :tool_registry, default: []
+        t.jsonb :prompt_registry, default: []
+        t.jsonb :resource_registry, default: []
+        t.timestamps
+      end
+    end
+
+    # Create session messages table
+    unless table_exists?(:action_mcp_session_messages)
+      create_table :action_mcp_session_messages do |t|
+        t.references :session, null: false,
+                    foreign_key: { to_table: :action_mcp_sessions,
+                                  on_delete: :cascade,
+                                  on_update: :cascade,
+                                  name: 'fk_action_mcp_session_messages_session_id' }, type: :string
+        t.string :direction, null: false, comment: 'The message recipient', default: 'client'
+        t.string :message_type, null: false, comment: 'The type of the message'
+        t.string :jsonrpc_id
+        t.jsonb :message_json
+        t.boolean :is_ping, default: false, null: false, comment: 'Whether the message is a ping'
+        t.boolean :request_acknowledged, default: false, null: false
+        t.boolean :request_cancelled, null: false, default: false
+        t.timestamps
+      end
+    end
+
+    # Create session subscriptions table
+    unless table_exists?(:action_mcp_session_subscriptions)
+      create_table :action_mcp_session_subscriptions do |t|
+        t.references :session,
+                    null: false,
+                    foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
+                    type: :string
+        t.string :uri, null: false
+        t.datetime :last_notification_at
+        t.timestamps
+      end
+    end
+
+    # Create session resources table
+    unless table_exists?(:action_mcp_session_resources)
+      create_table :action_mcp_session_resources do |t|
+        t.references :session,
+                    null: false,
+                    foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
+                    type: :string
+        t.string :uri, null: false
+        t.string :name
+        t.text :description
+        t.string :mime_type, null: false
+        t.boolean :created_by_tool, default: false
+        t.datetime :last_accessed_at
+        t.json :metadata
+        t.timestamps
+      end
+    end
+
+    # Create SSE events table
+    unless table_exists?(:action_mcp_sse_events)
+      create_table :action_mcp_sse_events do |t|
+        t.references :session, null: false, foreign_key: { to_table: :action_mcp_sessions }, index: true, type: :string
+        t.integer :event_id, null: false
+        t.text :data, null: false
+        t.timestamps
+
+        # Index for efficiently retrieving events after a given ID for a specific session
+        t.index [ :session_id, :event_id ], unique: true
+        t.index :created_at # For cleanup of old events
+      end
+    end
+
+    # Add missing columns to existing tables if they exist
+
+    # For action_mcp_sessions
+    if table_exists?(:action_mcp_sessions)
+      unless column_exists?(:action_mcp_sessions, :sse_event_counter)
+        add_column :action_mcp_sessions, :sse_event_counter, :integer, default: 0, null: false
+      end
+
+      unless column_exists?(:action_mcp_sessions, :tool_registry)
+        add_column :action_mcp_sessions, :tool_registry, :jsonb, default: []
+      end
+
+      unless column_exists?(:action_mcp_sessions, :prompt_registry)
+        add_column :action_mcp_sessions, :prompt_registry, :jsonb, default: []
+      end
+
+      unless column_exists?(:action_mcp_sessions, :resource_registry)
+        add_column :action_mcp_sessions, :resource_registry, :jsonb, default: []
+      end
+    end
+
+    # For action_mcp_session_messages
+    if table_exists?(:action_mcp_session_messages)
+      unless column_exists?(:action_mcp_session_messages, :is_ping)
+        add_column :action_mcp_session_messages, :is_ping, :boolean, default: false, null: false, comment: 'Whether the message is a ping'
+      end
+
+      unless column_exists?(:action_mcp_session_messages, :request_acknowledged)
+        add_column :action_mcp_session_messages, :request_acknowledged, :boolean, default: false, null: false
+      end
+
+      unless column_exists?(:action_mcp_session_messages, :request_cancelled)
+        add_column :action_mcp_session_messages, :request_cancelled, :boolean, null: false, default: false
+      end
+
+      if column_exists?(:action_mcp_session_messages, :message_text)
+        remove_column :action_mcp_session_messages, :message_text
+      end
+
+      if column_exists?(:action_mcp_session_messages, :direction)
+        change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
+      end
+    end
+  end
+
+  private
+
+  def table_exists?(table_name)
+    ActionMCP::ApplicationRecord.connection.table_exists?(table_name)
+  end
+
+  def column_exists?(table_name, column_name)
+    ActionMCP::ApplicationRecord.connection.column_exists?(table_name, column_name)
+  end
+end

data/exe/actionmcp_cli

@@ -24,6 +24,8 @@ end
 # Parse command-line arguments
 parser = OptionParser.new do |opts|
   opts.banner = 'Usage: mcp_client ENDPOINT [options]'
+  opts.separator ''
+  opts.separator 'ENDPOINT must be an HTTP(S) URL (e.g., http://localhost:3000/action_mcp)'
   opts.on('-l', '--log-level LEVEL', 'Set log level (DEBUG, INFO, WARN, ERROR)') do |l|
     options[:logging_level] = l.upcase
     logger.level = begin
@@ -53,6 +55,11 @@ if endpoint.nil?
   exit 1
 end
 
+unless endpoint =~ %r{\Ahttps?://}
+  puts "Error: Only HTTP(S) endpoints are supported. STDIO/command endpoints are not allowed."
+  exit 1
+end
+
 # Function to generate a unique request ID
 def generate_request_id
   SecureRandom.uuid
@@ -129,7 +136,7 @@ def print_help
   puts 'Otherwise, enter a raw JSON-RPC request to send directly'
 end
 
-# Initialize and start the client
+# Initialize and start the client (only HTTP(S) endpoints are supported)
 client = ActionMCP.create_client(endpoint, logger: logger)
 
 # Start the transport

data/lib/action_mcp/client.rb

@@ -3,27 +3,21 @@
 module ActionMCP
   # Creates a client appropriate for the given endpoint.
   #
-  # @param endpoint [String] The endpoint to connect to (URL or command).
+  # @param endpoint [String] The endpoint to connect to (URL).
   # @param logger [Logger] The logger to use. Default is Logger.new($stdout).
   # @param options [Hash] Additional options to pass to the client constructor.
   #
-  # @return [Client::SSEClient, Client::StdioClient] An instance of either SSEClient or StdioClient
-  #   depending on the format of the endpoint.
+  # @return [Client::SSEClient] An instance of SSEClient for HTTP(S) endpoints.
   #
   # @example
   #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
   #   client.connect
-  #
-  # @example
-  #   client = ActionMCP.create_client("some_command")
-  #   client.execute
   def self.create_client(endpoint, logger: Logger.new($stdout), **options)
     if endpoint =~ %r{\Ahttps?://}
       logger.info("Creating SSE client for endpoint: #{endpoint}")
       Client::SSEClient.new(endpoint, logger: logger, **options)
     else
-      logger.info("Creating STDIO client for command: #{endpoint}")
-      Client::StdioClient.new(endpoint, logger: logger, **options)
+      raise ArgumentError, "Only HTTP(S) endpoints are supported. STDIO and other transports are not supported."
     end
   end
 

data/lib/action_mcp/configuration.rb

@@ -22,8 +22,7 @@ module ActionMCP
                   :logging_level,
                   :active_profile,
                   :profiles,
-                  # --- New Transport Options ---
-                  :mcp_endpoint_path,
+                  # --- Transport Options ---
                   :sse_heartbeat_interval,
                   :post_response_preference, # :json or :sse
                   :protocol_version,
@@ -40,10 +39,9 @@ module ActionMCP
       @active_profile = :primary
       @profiles = default_profiles
 
-      @mcp_endpoint_path = "/mcp"
       @sse_heartbeat_interval = 30
       @post_response_preference = :json
-      @protocol_version = "2024-11-05"
+      @protocol_version = "2025-03-26"
 
       # Resumability defaults
       @enable_sse_resumability = true

data/lib/action_mcp/engine.rb

@@ -21,7 +21,7 @@ module ActionMCP
       ActionMCP::ResourceTemplate.registered_templates.clear
     end
 
-    config.middleware.use JSONRPC_Rails::Middleware::Validator, [ ActionMCP.configuration.mcp_endpoint_path ]
+    config.middleware.use JSONRPC_Rails::Middleware::Validator, [ "/" ]
 
     # Load MCP profiles during initialization
     initializer "action_mcp.load_profiles" do

data/lib/action_mcp/server/configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+
+module ActionMCP
+  module Server
+    # Configuration loader for ActionMCP server
+    class Configuration
+      attr_reader :config
+
+      def initialize(config_path = nil)
+        @config_path = config_path || default_config_path
+        @config = load_config
+      end
+
+      # Get the configuration for the current environment
+      def for_env(env = nil)
+        environment = env || (defined?(Rails) ? Rails.env : "development")
+        config[environment] || config["development"] || {}
+      end
+
+      # Get the adapter name for the current environment
+      def adapter_name(env = nil)
+        env_config = for_env(env)
+        env_config["adapter"]
+      end
+
+      # Get the adapter options for the current environment
+      def adapter_options(env = nil)
+        env_config = for_env(env)
+        env_config.except("adapter")
+      end
+
+      private
+
+      def load_config
+        return {} unless File.exist?(@config_path.to_s)
+
+        yaml = ERB.new(File.read(@config_path)).result
+        YAML.safe_load(yaml, aliases: true) || {}
+      rescue => e
+        Rails.logger.error("Error loading ActionMCP config: #{e.message}") if defined?(Rails) && Rails.respond_to?(:logger)
+        {}
+      end
+
+      def default_config_path
+        return Rails.root.join("config", "mcp.yml") if defined?(Rails) && Rails.respond_to?(:root)
+
+        # Fallback to looking for a mcp.yml in the current directory or parent directories
+        path = Dir.pwd
+        while path != "/"
+          config_path = File.join(path, "config", "mcp.yml")
+          return config_path if File.exist?(config_path)
+          path = File.dirname(path)
+        end
+
+        # Default to an empty config if no mcp.yml found
+        nil
+      end
+    end
+  end
+end

data/lib/action_mcp/server/simple_pub_sub.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "concurrent/map"
+require "concurrent/array"
+require "concurrent/executor/thread_pool_executor"
+
+module ActionMCP
+  module Server
+    # Simple in-memory PubSub implementation for testing and development
+    class SimplePubSub
+      # Thread pool configuration
+      DEFAULT_MIN_THREADS = 5
+      DEFAULT_MAX_THREADS = 10
+      DEFAULT_MAX_QUEUE = 100
+      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+
+      def initialize(options = {})
+        @subscriptions = Concurrent::Map.new
+        @channels = Concurrent::Map.new
+
+        # Initialize thread pool for callbacks
+        pool_options = {
+          min_threads: options["min_threads"] || DEFAULT_MIN_THREADS,
+          max_threads: options["max_threads"] || DEFAULT_MAX_THREADS,
+          max_queue: options["max_queue"] || DEFAULT_MAX_QUEUE,
+          fallback_policy: :caller_runs, # Execute in the caller's thread if queue is full
+          idletime: DEFAULT_THREAD_TIMEOUT
+        }
+        @thread_pool = Concurrent::ThreadPoolExecutor.new(pool_options)
+      end
+
+      # Subscribe to a channel
+      # @param channel [String] The channel name
+      # @param message_callback [Proc] Callback for received messages
+      # @param success_callback [Proc] Callback for successful subscription
+      # @return [String] Subscription ID
+      def subscribe(channel, message_callback, success_callback = nil)
+        subscription_id = SecureRandom.uuid
+
+        @subscriptions[subscription_id] = {
+          channel: channel,
+          message_callback: message_callback
+        }
+
+        @channels[channel] ||= Concurrent::Array.new
+        @channels[channel] << subscription_id
+
+        log_subscription_event(channel, "Subscribed", subscription_id)
+        success_callback&.call
+
+        subscription_id
+      end
+
+      # Check if we're already subscribed to a channel
+      # @param channel [String] The channel name
+      # @return [Boolean] True if we're already subscribed
+      def subscribed_to?(channel)
+        channel_subs = @channels[channel]
+        return false if channel_subs.nil?
+        !channel_subs.empty?
+      end
+
+      # Unsubscribe from a channel
+      # @param channel [String] The channel name
+      # @param callback [Proc] Optional callback for unsubscribe completion
+      def unsubscribe(channel, callback = nil)
+        # Remove our subscriptions
+        subscription_ids = @channels[channel] || []
+        subscription_ids.each do |subscription_id|
+          @subscriptions.delete(subscription_id)
+        end
+
+        @channels.delete(channel)
+
+        log_subscription_event(channel, "Unsubscribed")
+        callback&.call
+      end
+
+      # Broadcast a message to a channel
+      # @param channel [String] The channel name
+      # @param message [String] The message to broadcast
+      def broadcast(channel, message)
+        subscription_ids = @channels[channel] || []
+        return if subscription_ids.empty?
+
+        log_broadcast_event(channel, message)
+
+        subscription_ids.each do |subscription_id|
+          subscription = @subscriptions[subscription_id]
+          next unless subscription && subscription[:message_callback]
+
+          @thread_pool.post do
+            begin
+              subscription[:message_callback].call(message)
+            rescue StandardError => e
+              log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
+            end
+          end
+        end
+      end
+
+      # Check if a channel has subscribers
+      # @param channel [String] The channel name
+      # @return [Boolean] True if channel has subscribers
+      def has_subscribers?(channel)
+        subscribers = @channels[channel]
+        return false unless subscribers
+        !subscribers.empty?
+      end
+
+      # Shut down the thread pool gracefully
+      def shutdown
+        @thread_pool.shutdown
+        @thread_pool.wait_for_termination(5) # Wait up to 5 seconds for tasks to complete
+      end
+
+      private
+
+      def log_subscription_event(channel, action, subscription_id = nil)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        message = "SimplePubSub: #{action} channel=#{channel}"
+        message += " subscription_id=#{subscription_id}" if subscription_id
+
+        Rails.logger.debug(message)
+      end
+
+      def log_broadcast_event(channel, message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        # Truncate the message for logging
+        truncated_message = message.to_s[0..100]
+        truncated_message += "..." if message.to_s.length > 100
+
+        Rails.logger.debug("SimplePubSub: Broadcasting to channel=#{channel} message=#{truncated_message}")
+      end
+
+      def log_error(message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.error("SimplePubSub: #{message}")
+      end
+    end
+  end
+end