actionmcp 0.50.1 → 0.50.3

data/app/models/action_mcp/session.rb

@@ -167,9 +167,7 @@ module ActionMCP
       )
 
       # Maintain cache limit by removing oldest events if needed
-      if sse_events.count > max_events
-        sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all
-      end
+      sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all if sse_events.count > max_events
 
       event
     end
@@ -240,10 +238,10 @@ module ActionMCP
       tool_name = normalize_name(tool_class_or_name, :tool)
       self.tool_registry ||= []
 
-      if self.tool_registry.delete(tool_name)
-        save!
-        send_tools_list_changed_notification
-      end
+      return unless self.tool_registry.delete(tool_name)
+
+      save!
+      send_tools_list_changed_notification
     end
 
     def register_prompt(prompt_class_or_name)
@@ -263,10 +261,10 @@ module ActionMCP
       prompt_name = normalize_name(prompt_class_or_name, :prompt)
       self.prompt_registry ||= []
 
-      if self.prompt_registry.delete(prompt_name)
-        save!
-        send_prompts_list_changed_notification
-      end
+      return unless self.prompt_registry.delete(prompt_name)
+
+      save!
+      send_prompts_list_changed_notification
     end
 
     def register_resource_template(template_class_or_name)
@@ -286,28 +284,34 @@ module ActionMCP
       template_name = normalize_name(template_class_or_name, :resource_template)
       self.resource_registry ||= []
 
-      if self.resource_registry.delete(template_name)
-        save!
-        send_resources_list_changed_notification
-      end
+      return unless self.resource_registry.delete(template_name)
+
+      save!
+      send_resources_list_changed_notification
     end
 
     # Get registered items for this session
     def registered_tools
       (self.tool_registry || []).filter_map do |tool_name|
-        ActionMCP::ToolsRegistry.find(tool_name) rescue nil
+        ActionMCP::ToolsRegistry.find(tool_name)
+      rescue StandardError
+        nil
       end
     end
 
     def registered_prompts
       (self.prompt_registry || []).filter_map do |prompt_name|
-        ActionMCP::PromptsRegistry.find(prompt_name) rescue nil
+        ActionMCP::PromptsRegistry.find(prompt_name)
+      rescue StandardError
+        nil
       end
     end
 
     def registered_resource_templates
       (self.resource_registry || []).filter_map do |template_name|
-        ActionMCP::ResourceTemplatesRegistry.find(template_name) rescue nil
+        ActionMCP::ResourceTemplatesRegistry.find(template_name)
+      rescue StandardError
+        nil
       end
     end
 
@@ -379,21 +383,21 @@ module ActionMCP
 
     def send_tools_list_changed_notification
       # Only send if server capabilities allow it
-      if server_capabilities.dig("tools", "listChanged")
-        write(JSON_RPC::Notification.new(method: "notifications/tools/list_changed"))
-      end
+      return unless server_capabilities.dig("tools", "listChanged")
+
+      write(JSON_RPC::Notification.new(method: "notifications/tools/list_changed"))
     end
 
     def send_prompts_list_changed_notification
-      if server_capabilities.dig("prompts", "listChanged")
-        write(JSON_RPC::Notification.new(method: "notifications/prompts/list_changed"))
-      end
+      return unless server_capabilities.dig("prompts", "listChanged")
+
+      write(JSON_RPC::Notification.new(method: "notifications/prompts/list_changed"))
     end
 
     def send_resources_list_changed_notification
-      if server_capabilities.dig("resources", "listChanged")
-        write(JSON_RPC::Notification.new(method: "notifications/resources/list_changed"))
-      end
+      return unless server_capabilities.dig("resources", "listChanged")
+
+      write(JSON_RPC::Notification.new(method: "notifications/resources/list_changed"))
     end
   end
 end

data/app/models/concerns/mcp_console_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # app/models/concerns/mcp_console_helpers.rb
 module MCPConsoleHelpers
   extend ActiveSupport::Concern
@@ -12,9 +14,7 @@ module MCPConsoleHelpers
 
       messages.each do |msg|
         puts msg.inspect
-        if msg.data&.dig("method")
-          puts "  └─ #{msg.data['method']}"
-        end
+        puts "  └─ #{msg.data['method']}" if msg.data&.dig("method")
         puts
       end
     end

data/app/models/concerns/mcp_message_inspect.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # app/models/concerns/mcp_message_inspect.rb
 module MCPMessageInspect
   extend ActiveSupport::Concern
 
   def inspect(show_data: false)
     if show_data
-      super()  # Rails default inspect
+      super() # Rails default inspect
     else
       build_summary_inspect
     end
@@ -54,9 +56,7 @@ module MCPMessageInspect
 
   def console?
     # Check if we're in a Rails console environment
-    defined?(Rails::Console) ||
-      defined?(::Rails.application) && Rails.application.console? ||
-      (defined?(IRB) && IRB.CurrentContext.kind_of?(IRB::ExtendCommandBundle))
+    defined?(Rails::Console)
   end
 
   def colorize(text, color)

data/config/routes.rb

@@ -4,7 +4,7 @@ ActionMCP::Engine.routes.draw do
   get "/up", to: "/rails/health#show", as: :action_mcp_health_check
 
   # 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
+  get "/", to: "application#show", as: :mcp_get
+  post "/", to: "application#create", as: :mcp_post
+  delete "/", to: "application#destroy", as: :mcp_delete
 end

data/db/migrate/20250512154359_consolidated_migration.rb

@@ -29,10 +29,10 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     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
+                               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
@@ -48,9 +48,9 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     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
+                     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
@@ -61,9 +61,9 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     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
+                     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
@@ -84,7 +84,7 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
         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 %i[session_id event_id], unique: true
         t.index :created_at # For cleanup of old events
       end
     end
@@ -111,27 +111,28 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     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
+    return unless table_exists?(:action_mcp_session_messages)
 
-      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, :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_cancelled)
-        add_column :action_mcp_session_messages, :request_cancelled, :boolean, null: false, default: false
-      end
+    unless column_exists?(:action_mcp_session_messages, :request_acknowledged)
+      add_column :action_mcp_session_messages, :request_acknowledged, :boolean, default: false, null: false
+    end
 
-      if column_exists?(:action_mcp_session_messages, :message_text)
-        remove_column :action_mcp_session_messages, :message_text
-      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, :direction)
-        change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
-      end
+    if column_exists?(:action_mcp_session_messages, :message_text)
+      remove_column :action_mcp_session_messages, :message_text
     end
+
+    return unless column_exists?(:action_mcp_session_messages, :direction)
+
+    change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
   end
 
   private

data/exe/actionmcp_cli

@@ -56,7 +56,7 @@ if endpoint.nil?
 end
 
 unless endpoint =~ %r{\Ahttps?://}
-  puts "Error: Only HTTP(S) endpoints are supported. STDIO/command endpoints are not allowed."
+  puts 'Error: Only HTTP(S) endpoints are supported. STDIO/command endpoints are not allowed.'
   exit 1
 end
 

data/lib/action_mcp/client.rb

@@ -13,12 +13,12 @@ module ActionMCP
   #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
   #   client.connect
   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
+    unless endpoint =~ %r{\Ahttps?://}
       raise ArgumentError, "Only HTTP(S) endpoints are supported. STDIO and other transports are not supported."
     end
+
+    logger.info("Creating SSE client for endpoint: #{endpoint}")
+    Client::SSEClient.new(endpoint, logger: logger, **options)
   end
 
   module Client

data/lib/action_mcp/engine.rb

@@ -47,5 +47,32 @@ module ActionMCP
     initializer "action_mcp.logger" do
       ActionMCP.logger = ::Rails.logger
     end
+
+    # Add metrics instrumentation
+    initializer "action_mcp.metrics" do
+      ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
+        if payload[:controller].to_s.start_with?("ActionMCP::")
+          # Process action through our log subscriber
+          ActionMCP::LogSubscriber.new.process_action(
+            ActiveSupport::Notifications::Event.new(name, start, finish, id, payload)
+          )
+        end
+      end
+
+      # Set up default event metrics
+      # SQL queries
+      ActionMCP::LogSubscriber.subscribe_event "sql.active_record", :db_queries, accumulate: true
+
+      # Query runtime
+      ActionMCP::LogSubscriber.subscribe_event "sql.active_record", :sql_runtime,
+                                               duration: true, accumulate: true
+
+      # View rendering
+      ActionMCP::LogSubscriber.subscribe_event "render_template.action_view", :view_runtime,
+                                               duration: true, accumulate: true
+
+      # Cache operations
+      ActionMCP::LogSubscriber.subscribe_event "cache_*.*", :cache_operations, accumulate: true
+    end
   end
 end

data/lib/action_mcp/instrumentation/controller_runtime.rb

@@ -28,7 +28,7 @@ module ActionMCP
         def log_process_action(payload)
           messages = super
           mcp_runtime = payload[:mcp_runtime]
-          messages << (format("MCP: %.1fms", mcp_runtime.to_f)) if mcp_runtime
+          messages << format("MCP: %.1fms", mcp_runtime.to_f) if mcp_runtime
           messages
         end
       end

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -75,6 +75,7 @@ module ActionMCP
     # @param request [Hash]
     def process_request(request)
       return unless valid_request?(request)
+
       request = request.with_indifferent_access
 
       read(request)

data/lib/action_mcp/log_subscriber.rb

@@ -2,6 +2,11 @@
 
 module ActionMCP
   class LogSubscriber < ActiveSupport::LogSubscriber
+    # Thread-local storage for additional metrics
+    class << self
+      attr_accessor :custom_metrics, :subscribed_events, :formatters, :metric_groups
+    end
+
     def self.reset_runtime
       # Get the combined runtime from both tool and prompt operations
       tool_rt = Thread.current[:mcp_tool_runtime] || 0
@@ -26,6 +31,161 @@ module ActionMCP
       Thread.current[:mcp_prompt_runtime] += event.duration
     end
 
+    # Add a custom metric to be included in logs
+    def self.add_metric(name, value)
+      self.custom_metrics ||= {}
+      self.custom_metrics[name] = value
+    end
+
+    # Measure execution time of a block and add as metric
+    def self.measure_metric(name)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = yield
+      duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0
+
+      add_metric(name, duration)
+      result
+    end
+
+    # Reset all custom metrics
+    def self.reset_metrics
+      self.custom_metrics = nil
+    end
+
+    # Subscribe to a Rails event to capture metrics
+    # @param pattern [String] Event name pattern (e.g., "sql.active_record")
+    # @param metric_name [Symbol] Name to use for the metric
+    # @param options [Hash] Options for capturing the metric
+    def self.subscribe_event(pattern, metric_name, options = {})
+      self.subscribed_events ||= {}
+
+      # Store subscription info
+      self.subscribed_events[pattern] = {
+        metric_name: metric_name,
+        options: options
+      }
+
+      # Create the actual subscription
+      ActiveSupport::Notifications.subscribe(pattern) do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+
+        # Extract value based on options
+        value = if options[:duration]
+                  event.duration
+        elsif options[:extract_value].respond_to?(:call)
+                  options[:extract_value].call(event)
+        else
+                  1 # Default to count
+        end
+
+        # Accumulate or set the metric
+        if options[:accumulate]
+          self.custom_metrics ||= {}
+          self.custom_metrics[metric_name] ||= 0
+          self.custom_metrics[metric_name] += value
+        else
+          add_metric(metric_name, value)
+        end
+      end
+    end
+
+    # Format metrics for display in logs
+    def self.format_metrics
+      return nil if custom_metrics.nil? || custom_metrics.empty?
+
+      # If grouping is enabled, organize metrics by groups
+      if metric_groups.present?
+        grouped_metrics = {}
+
+        # Initialize groups with empty arrays
+        metric_groups.each_key do |group_name|
+          grouped_metrics[group_name] = []
+        end
+
+        # Add "other" group for ungrouped metrics
+        grouped_metrics[:other] = []
+
+        # Assign metrics to their groups
+        custom_metrics.each do |key, value|
+          group = nil
+
+          # Find which group this metric belongs to
+          metric_groups.each do |group_name, metrics|
+            if metrics.include?(key)
+              group = group_name
+              break
+            end
+          end
+
+          # Format the metric
+          formatter = formatters&.dig(key)
+          formatted_value = if formatter.respond_to?(:call)
+                              formatter.call(value)
+          elsif value.is_a?(Float)
+                              format("%.1fms", value)
+          else
+                              value.to_s
+          end
+
+          formatted_metric = "#{key}: #{formatted_value}"
+
+          # Add to appropriate group (or "other")
+          if group
+            grouped_metrics[group] << formatted_metric
+          else
+            grouped_metrics[:other] << formatted_metric
+          end
+        end
+
+        # Join metrics within groups, then join groups
+        grouped_metrics.map do |_group, metrics|
+          next if metrics.empty?
+
+          metrics.join(" | ")
+        end.compact.join(" | ")
+      else
+        # No grouping, just format all metrics
+        custom_metrics.map do |key, value|
+          formatter = formatters&.dig(key)
+          formatted_value = if formatter.respond_to?(:call)
+                              formatter.call(value)
+          elsif value.is_a?(Float)
+                              format("%.1fms", value)
+          else
+                              value.to_s
+          end
+          "#{key}: #{formatted_value}"
+        end.join(" | ")
+      end
+    end
+
+    # Register a custom formatter for a specific metric
+    # @param metric_name [Symbol] The name of the metric
+    # @param block [Proc] The formatter block that takes the value and returns a string
+    def self.register_formatter(metric_name, &block)
+      self.formatters ||= {}
+      self.formatters[metric_name] = block
+    end
+
+    # Define a group of related metrics
+    # @param group_name [Symbol] The name of the metric group
+    # @param metrics [Array<Symbol>] The metrics that belong to this group
+    def self.define_metric_group(group_name, metrics)
+      self.metric_groups ||= {}
+      self.metric_groups[group_name] = metrics
+    end
+
+    # Enhance process_action to include our custom metrics
+    def process_action(event)
+      return unless logger.info?
+
+      return unless self.class.custom_metrics.present?
+
+      metrics_msg = self.class.format_metrics
+      event.payload[:message] = "#{event.payload[:message]} | #{metrics_msg}" if metrics_msg
+      self.class.reset_metrics
+    end
+
     attach_to :action_mcp
   end
 end

data/lib/action_mcp/resource_template.rb

@@ -13,7 +13,7 @@ module ActionMCP
 
     # Track all registered templates
     @registered_templates = []
-    attr_reader :execution_context
+    attr_reader :execution_context, :description, :uri_template, :mime_type
 
     class << self
       attr_reader :registered_templates, :description, :uri_template,
@@ -227,8 +227,6 @@ module ActionMCP
       end
     end
 
-    attr_reader :description, :uri_template, :mime_type
-
     def call
       run_callbacks :resolve do
         resolve

data/lib/action_mcp/server/capabilities.rb

@@ -16,7 +16,8 @@ module ActionMCP
 
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
           send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'protocolVersion'" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'protocolVersion'" } } }
         end
         # Check if the protocol version is supported
         unless ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
@@ -25,20 +26,21 @@ module ActionMCP
             requested: client_protocol_version
           }
           send_jsonrpc_error(request_id, :invalid_params, "Unsupported protocol version", error_data)
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Unsupported protocol version", data: error_data } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Unsupported protocol version", data: error_data } } }
         end
 
         unless client_info.is_a?(Hash)
           send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'clientInfo'")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'clientInfo'" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'clientInfo'" } } }
         end
         unless client_capabilities.is_a?(Hash)
           send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'capabilities'" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'capabilities'" } } }
         end
 
-
-
         # Store client information
         session.store_client_info(client_info)
         session.store_client_capabilities(client_capabilities)
@@ -47,12 +49,13 @@ module ActionMCP
         # Initialize the session
         unless session.initialize!
           send_jsonrpc_error(request_id, :internal_error, "Failed to initialize session")
-          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32603, message: "Failed to initialize session" } } }
+          return { type: :error, id: request_id,
+                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_603, message: "Failed to initialize session" } } }
         end
 
         # Send the successful response with the protocol version the client requested
         capabilities_payload = session.server_capabilities_payload
-        capabilities_payload[:protocolVersion] = client_protocol_version  # Use the client's requested version
+        capabilities_payload[:protocolVersion] = client_protocol_version # Use the client's requested version
 
         send_jsonrpc_response(request_id, result: capabilities_payload)
         { type: :responses, id: request_id, payload: { jsonrpc: "2.0", id: request_id, result: capabilities_payload } }

data/lib/action_mcp/server/configuration.rb

@@ -39,8 +39,10 @@ module ActionMCP
 
         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)
+      rescue StandardError => e
+        if defined?(Rails) && Rails.respond_to?(:logger)
+          Rails.logger.error("Error loading ActionMCP config: #{e.message}")
+        end
         {}
       end
 
@@ -52,6 +54,7 @@ module ActionMCP
         while path != "/"
           config_path = File.join(path, "config", "mcp.yml")
           return config_path if File.exist?(config_path)
+
           path = File.dirname(path)
         end