mcp_logs 0.1.0

data/app/models/mcp_logs/docs.rb

@@ -0,0 +1,81 @@
+module McpLogs
+  # Renders a server's tool contract as reference documentation for a person, as
+  # opposed to the server itself, which serves it to an agent.
+  #
+  # Reads MCP::Tool.to_h rather than the tool classes' own DSL, because to_h is
+  # the exact payload tools/list returns — so the page cannot drift from what a
+  # connected client actually receives.
+  module Docs
+    Param   = Data.define(:name, :type, :required, :description)
+    Tool    = Data.define(:name, :title, :description, :params)
+    Section = Data.define(:title, :tools)
+
+    UNGROUPED = "Ungrouped".freeze
+
+    module_function
+
+    # `sections` is { "Title" => ["tool_name", ...] }, in the order the host wants
+    # them rendered. A tool missing from every section still renders, under
+    # UNGROUPED, so an omission is visible rather than silent.
+    def sections(server, sections = McpLogs.tool_sections)
+      return [] if server.nil?
+
+      by_name = tools_by_name(server)
+
+      grouped = sections.map do |title, names|
+        Section.new(title: title, tools: names.filter_map { |name| by_name[name.to_s] }.map { |klass| tool(klass) })
+      end
+
+      leftover = by_name.except(*sections.values.flatten.map(&:to_s))
+      grouped << Section.new(title: UNGROUPED, tools: leftover.values.map { |klass| tool(klass) }) if leftover.any?
+
+      grouped.reject { |section| section.tools.empty? }
+    end
+
+    # MCP::Server#tools is already { name => tool class }; going through it rather
+    # than the class list means the page shows exactly what the server serves.
+    def tools_by_name(server)
+      server.tools.transform_keys(&:to_s)
+    end
+
+    def tool(klass)
+      contract = klass.to_h
+
+      Tool.new(
+        name: contract[:name],
+        title: contract[:title],
+        description: contract[:description].to_s.strip,
+        params: params(contract[:inputSchema] || {})
+      )
+    end
+
+    # Property keys arrive as Symbols but the `required` array holds Strings, so
+    # membership has to be tested on strings. Comparing the Symbol key directly
+    # against `required` returns false for every parameter, silently rendering the
+    # whole contract as optional.
+    def params(schema)
+      required = Array(schema[:required] || schema["required"]).map(&:to_s)
+      properties = schema[:properties] || schema["properties"] || {}
+
+      properties.map do |name, spec|
+        spec = spec.symbolize_keys if spec.respond_to?(:symbolize_keys)
+
+        Param.new(
+          name: name.to_s,
+          type: type_label(spec),
+          required: required.include?(name.to_s),
+          description: spec[:description].to_s
+        )
+      end
+    end
+
+    # Folds enum and array item type into the type label rather than the view, so
+    # a schema's accepted values are visible on the page instead of only in the
+    # tool's source file.
+    def type_label(spec)
+      base = spec[:type].to_s
+      base = "#{base} of #{spec.dig(:items, :type)}" if base == "array" && spec.dig(:items, :type)
+      spec[:enum] ? "#{base} (#{spec[:enum].join(" | ")})" : base
+    end
+  end
+end

data/app/models/mcp_logs/recorder.rb

@@ -0,0 +1,204 @@
+module McpLogs
+  # The body of the lambda a host hands to MCP::Configuration#around_request.
+  #
+  # The gem calls it as `around_request.call(data, &block)`, where `data` is a
+  # hash the server keeps writing into for the duration of the block: tool_name,
+  # tool_arguments, client and error all land *during* the call, not before it.
+  # So the row is inserted with what is known up front (the method) and completed
+  # with everything else once the block returns.
+  #
+  # Load-bearing requirement on the host: build a fresh MCP::Server per request.
+  # In mcp 1.0.0 the `data` hash above is not per-request — it is
+  # `@instrumentation_data`, a plain instance variable on the MCP::Server
+  # object, reassigned to `{}` at the top of every `instrument_call`
+  # (lib/mcp/instrumentation.rb). If one server instance serves two concurrent
+  # requests, request B's reassignment can land while A is still mid-handler,
+  # so A's later `tool_name`/`tool_arguments`/`error` writes end up in B's hash
+  # instead of A's. This recorder only holds the reference it was handed and
+  # trusts it describes the request in progress; it has no way to detect or
+  # correct for a shared server, so the host must not memoize or share one.
+  class Recorder
+    # error_message goes into a plain text column, not jsonb, and has no
+    # upstream size bound the way arguments/response do via Payload: exception
+    # messages routinely echo attribute values or an entire failing SQL
+    # statement. This is a size bound only, not redaction — filtering
+    # free-text exception messages is out of scope here.
+    ERROR_MESSAGE_BYTES = 2_000
+
+    # Cap for every string column a client can influence: tool_name, session_id,
+    # client_name, client_version, protocol_version, user_agent.
+    #
+    # These are not validated input. mcp 1.0.0 reads tool_name straight from
+    # params.name and hands it to this hook *before* looking the tool up, so an
+    # unknown tool records whatever the client sent; the rest are raw request
+    # headers. Uncapped, one looping client writes megabyte rows for the whole
+    # retention window and puts one <option> per distinct value on the calls
+    # page — taking down the page an operator would open to find out why.
+    #
+    # 255 is the migration's `limit:`, and PostgreSQL's varchar(n) counts
+    # characters, so this counts characters too and a value cut here always
+    # fits. It is far above every legitimate value (a tool name is an
+    # identifier, a session id a UUID, a protocol version a date), which is why
+    # the cut is silent: unlike a capped payload there is nothing an operator
+    # would want back, so it gets no *_truncated flag.
+    STRING_LIMIT = 255
+
+    def self.around_request(server_name: nil)
+      recorder = new(server_name: server_name)
+      ->(data, &handler) { recorder.call(data, &handler) }
+    end
+
+    def initialize(server_name: nil)
+      @server_name = server_name
+    end
+
+    def call(data, &handler)
+      return handler.call unless McpLogs.enabled?
+
+      record  = start(data)
+      started = clock
+
+      begin
+        response = handler.call
+      rescue Exception => exception # rubocop:disable Lint/RescueException
+        # Re-raised immediately and unchanged; the rescue exists only so a
+        # failing request still gets a completed row rather than a stuck one.
+        finish(record, data, started: started, exception: exception)
+        raise
+      end
+
+      finish(record, data, started: started, response: response)
+      response
+    end
+
+    private
+
+    # data[:duration] is set in the gem's `ensure`, which runs after this lambda
+    # returns, so the recorder times the handler itself.
+    def clock = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    def start(data)
+      guarded do
+        Call.create!(
+          {
+            server_name: @server_name,
+            rpc_method: data[:method].to_s,
+            status: "running",
+            started_at: Time.current
+          }.merge(capped_context)
+        )
+      end
+    end
+
+    def finish(record, data, started:, response: nil, exception: nil)
+      return if record.nil?
+
+      # Measured before Payload.prepare and the write below do their own work,
+      # so duration_ms times the handler, not the recorder's own bookkeeping.
+      elapsed_ms = (clock - started) * 1000
+
+      guarded do
+        arguments, arguments_truncated = Payload.prepare(data[:tool_arguments])
+        body, response_truncated = Payload.prepare(result_payload(response))
+        error_message, error_message_truncated = capped_error_message(exception)
+
+        # update_columns, not update!: this writes every column named below
+        # unconditionally, where update! sends only the ones ActiveRecord considers
+        # dirty relative to the object `start` built. That difference matters for
+        # exactly one case, and it is not hypothetical. If the sweep settled this
+        # row as abandoned while the handler was still running, the row now carries
+        # an error_type and error_message this in-memory object has never seen —
+        # and since both are nil in memory AND nil in the assignment below, dirty
+        # tracking omits them, leaving a completed call permanently labelled
+        # abandoned. Validations go with them: these values are constructed rather
+        # than user input, and a validation failure would only be swallowed by
+        # `guarded` anyway.
+        record.update_columns(
+          updated_at: Time.current,
+          tool_name: capped(data[:tool_name]),
+          arguments: arguments,
+          arguments_truncated: arguments_truncated,
+          response: body,
+          response_truncated: response_truncated,
+          tool_error: tool_error?(response),
+          cancelled: !!data[:cancelled],
+          status: (exception || data[:error]) ? "error" : "ok",
+          error_type: data[:error]&.to_s || exception&.class&.name,
+          error_message: error_message,
+          error_message_truncated: error_message_truncated,
+          client_name: capped(client(data)[:name]),
+          client_version: capped(client(data)[:version]),
+          duration_ms: elapsed_ms,
+          completed_at: Time.current
+        )
+      end
+    end
+
+    # A cancelled request returns the gem's NO_RESPONSE sentinel, and non-tool
+    # methods can return anything; only a Hash is worth storing as a result.
+    def result_payload(response)
+      response.is_a?(Hash) ? response : nil
+    end
+
+    # An MCP::Tool::Response built with error: true serializes to isError: true.
+    # That is a *successful* JSON-RPC response carrying a tool-level failure —
+    # a rejected pattern, an already-resolved domain — so it gets its own flag
+    # rather than being folded into status.
+    def tool_error?(response)
+      return false unless response.is_a?(Hash)
+
+      !!(response[:isError] || response["isError"])
+    end
+
+    def client(data)
+      value = data[:client]
+      value.is_a?(Hash) ? value.symbolize_keys : {}
+    end
+
+    # actor is the host's own label rather than anything the client sent, but it
+    # shares a column width with the rest, so it is capped alongside them.
+    def capped_context
+      Context.current
+        .slice(:session_id, :protocol_version, :actor, :ip, :user_agent)
+        .transform_values { |value| capped(value) }
+    end
+
+    def capped(value)
+      value && value.to_s.truncate(STRING_LIMIT, omission: "")
+    end
+
+    def capped_error_message(exception)
+      return [nil, false] unless exception
+
+      message = "#{exception.class}: #{exception.message}"
+      return [message, false] if message.bytesize <= ERROR_MESSAGE_BYTES
+
+      # byteslice can cut mid-character; scrub keeps the column valid UTF-8.
+      [message.byteslice(0, ERROR_MESSAGE_BYTES).scrub(""), true]
+    end
+
+    # The log is never the reason a tool call fails. A failed statement inside
+    # an open PostgreSQL transaction leaves the connection aborted, so every
+    # subsequent query on it fails too — including the handler's own, if it is
+    # running inside a transaction of its own. requires_new: true opens a
+    # savepoint instead of reusing the surrounding one, so a failure here rolls
+    # back only the log write and leaves any enclosing transaction usable.
+    def guarded
+      Call.transaction(requires_new: true) { yield }
+    rescue StandardError => exception
+      # The report is itself guarded. Anything escaping this method reaches
+      # MCP::Instrumentation#instrument_call, which reports and re-raises, so a
+      # failing error reporter would turn an already-committed tool write into a
+      # -32603 for the client — which an agent will retry, duplicating the
+      # write. ErrorReporter#report already swallows subscriber failures when a
+      # logger is present, so this is near-unreachable; it is also the only line
+      # in the recorder that was outside the guarantee the rest of it makes.
+      begin
+        Rails.error.report(exception, handled: true, source: "mcp_logs")
+      rescue StandardError
+        nil
+      end
+      nil
+    end
+  end
+end

data/app/views/layouts/mcp_logs/application.html.erb

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title><%= content_for(:title) || "MCP Logs" %></title>
+    <%= stylesheet_link_tag "mcp_logs" %>
+  </head>
+
+  <body class="mcpl">
+    <nav class="mcpl-nav">
+      <div class="mcpl-nav-inner">
+        <strong>MCP Logs</strong>
+        <%= link_to "Calls", mcp_logs.calls_path,
+              "aria-current": ("page" if request.path.start_with?(mcp_logs.calls_path) || request.path == mcp_logs.root_path) %>
+        <%= link_to "Docs", mcp_logs.docs_path,
+              "aria-current": ("page" if request.path == mcp_logs.docs_path) %>
+      </div>
+    </nav>
+
+    <main class="mcpl-main">
+      <%= yield %>
+    </main>
+  </body>
+</html>

data/app/views/mcp_logs/calls/_pagination.html.erb

@@ -0,0 +1,18 @@
+<%# Built from the Pagy object's plain readers; pagy's own nav helpers ship their
+    own markup and stylesheet, neither of which fits this layout. %>
+<nav class="mcpl-pagination" aria-label="Pagination">
+  <span class="mcpl-muted">
+    <% if pagy.count.zero? %>
+      Nothing to show
+    <% else %>
+      <%= number_with_delimiter(pagy.from) %>–<%= number_with_delimiter(pagy.to) %>
+      of <%= number_with_delimiter(pagy.count) %>
+    <% end %>
+  </span>
+
+  <span>
+    <%= link_to "‹ Prev", pagy.page_url(:previous) if pagy.previous %>
+    <span class="mcpl-muted">Page <%= pagy.page %> of <%= pagy.last %></span>
+    <%= link_to "Next ›", pagy.page_url(:next) if pagy.next %>
+  </span>
+</nav>

data/app/views/mcp_logs/calls/index.html.erb

@@ -0,0 +1,62 @@
+<% content_for :title, "Calls — MCP Logs" %>
+
+<div class="mcpl-panel">
+  <h2>Filter</h2>
+  <div class="mcpl-panel-body">
+    <%= form_with url: mcp_logs.calls_path, method: :get, class: "mcpl-filters" do |form| %>
+      <div>
+        <%= form.label :method, "Method" %>
+        <%= form.select :method, @methods, { include_blank: "Any" }, selected: params[:method] %>
+      </div>
+      <div>
+        <%= form.label :tool, "Tool" %>
+        <%= form.select :tool, @tools, { include_blank: "Any" }, selected: params[:tool] %>
+      </div>
+      <div>
+        <%= form.label :status, "Status" %>
+        <%= form.select :status, McpLogs::Call::STATUSES, { include_blank: "Any" }, selected: params[:status] %>
+      </div>
+      <div>
+        <%= form.label :session, "Session" %>
+        <%= form.text_field :session, value: params[:session] %>
+      </div>
+      <%= form.submit "Apply" %>
+      <%= link_to "Clear", mcp_logs.calls_path %>
+    <% end %>
+  </div>
+</div>
+
+<div class="mcpl-panel">
+  <h2>Calls</h2>
+
+  <% if @calls.empty? %>
+    <div class="mcpl-panel-body mcpl-muted">No calls recorded yet.</div>
+  <% else %>
+    <table class="mcpl-table">
+      <thead>
+        <tr>
+          <th>Started</th>
+          <th>Method</th>
+          <th>Tool</th>
+          <th>Status</th>
+          <th>Duration</th>
+          <th>Client</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @calls.each do |call| %>
+          <tr>
+            <td><%= link_to l(call.started_at, format: :short), mcp_logs.call_path(call) %></td>
+            <td class="mcpl-mono"><%= call.rpc_method %></td>
+            <td class="mcpl-mono"><%= mcpl_value(call.tool_name) %></td>
+            <td><%= mcpl_status_badge(call) %></td>
+            <td><%= mcpl_duration(call) %></td>
+            <td><%= mcpl_value(call.actor || call.client_name) %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% end %>
+
+  <%= render "pagination", pagy: @pagy %>
+</div>

data/app/views/mcp_logs/calls/show.html.erb

@@ -0,0 +1,104 @@
+<% content_for :title, "Call ##{@call.id} — MCP Logs" %>
+
+<p><%= link_to "← Calls", mcp_logs.calls_path %></p>
+
+<div class="mcpl-panel">
+  <h2><%= @call.rpc_method %><%= " · #{@call.tool_name}" if @call.tool_name %></h2>
+  <div class="mcpl-panel-body">
+    <dl class="mcpl-meta">
+      <div>
+        <dt>Status</dt>
+        <dd><%= mcpl_status_badge(@call) %></dd>
+      </div>
+      <div>
+        <dt>Started</dt>
+        <dd><%= l(@call.started_at, format: :short) %></dd>
+      </div>
+      <div>
+        <dt>Duration</dt>
+        <dd><%= mcpl_duration(@call) %></dd>
+      </div>
+      <div>
+        <dt>Tool</dt>
+        <dd>
+          <% if @call.tool_name %>
+            <%= link_to @call.tool_name, mcp_logs.calls_path(tool: @call.tool_name) %>
+          <% else %>
+            <span class="mcpl-muted">—</span>
+          <% end %>
+        </dd>
+      </div>
+      <div>
+        <dt>Session</dt>
+        <dd>
+          <% if @call.session_id %>
+            <%= link_to @call.session_id, mcp_logs.calls_path(session: @call.session_id) %>
+          <% else %>
+            <span class="mcpl-muted">—</span>
+          <% end %>
+        </dd>
+      </div>
+      <div>
+        <dt>Actor</dt>
+        <dd><%= mcpl_value(@call.actor) %></dd>
+      </div>
+      <div>
+        <dt>Client</dt>
+        <dd><%= mcpl_value([@call.client_name, @call.client_version].compact.join(" ")) %></dd>
+      </div>
+      <div>
+        <dt>Protocol</dt>
+        <dd><%= mcpl_value(@call.protocol_version) %></dd>
+      </div>
+      <div>
+        <dt>Server</dt>
+        <dd><%= mcpl_value(@call.server_name) %></dd>
+      </div>
+      <div>
+        <dt>IP</dt>
+        <dd><%= mcpl_value(@call.ip) %></dd>
+      </div>
+      <div>
+        <dt>User agent</dt>
+        <dd><%= mcpl_value(@call.user_agent) %></dd>
+      </div>
+      <div>
+        <dt>Cancelled</dt>
+        <dd><%= @call.cancelled ? "yes" : "no" %></dd>
+      </div>
+    </dl>
+  </div>
+</div>
+
+<% if @call.status == "error" || @call.error_message.present? %>
+  <div class="mcpl-panel">
+    <h2>Error</h2>
+    <div class="mcpl-panel-body">
+      <% if @call.error_message_truncated %>
+        <p class="mcpl-muted">This message was capped at <%= number_with_delimiter(McpLogs::Recorder::ERROR_MESSAGE_BYTES) %> bytes — what follows is the capped text, not the whole message.</p>
+      <% end %>
+      <p class="mcpl-mono"><%= mcpl_value(@call.error_type) %></p>
+      <p><%= mcpl_value(@call.error_message) %></p>
+    </div>
+  </div>
+<% end %>
+
+<div class="mcpl-panel">
+  <h2>Arguments</h2>
+  <div class="mcpl-panel-body">
+    <% if @call.arguments_truncated %>
+      <p class="mcpl-muted">This payload was capped at <%= number_with_delimiter(McpLogs.max_payload_bytes) %> bytes — what follows is the capped record, not the whole exchange.</p>
+    <% end %>
+    <%= mcpl_json(@call.arguments) %>
+  </div>
+</div>
+
+<div class="mcpl-panel">
+  <h2>Response</h2>
+  <div class="mcpl-panel-body">
+    <% if @call.response_truncated %>
+      <p class="mcpl-muted">This payload was capped at <%= number_with_delimiter(McpLogs.max_payload_bytes) %> bytes — what follows is the capped record, not the whole exchange.</p>
+    <% end %>
+    <%= mcpl_json(@call.response) %>
+  </div>
+</div>

data/app/views/mcp_logs/docs/show.html.erb

@@ -0,0 +1,75 @@
+<% content_for :title, "Docs — MCP Logs" %>
+
+<% if @server.nil? %>
+  <div class="mcpl-panel">
+    <h2>Docs</h2>
+    <div class="mcpl-panel-body">
+      <p>No MCP server is configured. Set <code class="mcpl-mono">config.server</code> in your
+        <code class="mcpl-mono">mcp_logs</code> initializer to a lambda returning your
+        <code class="mcpl-mono">MCP::Server</code>, and this page will document its tools.</p>
+    </div>
+  </div>
+<% else %>
+  <div class="mcpl-panel">
+    <h2><%= @server.name %></h2>
+    <div class="mcpl-panel-body">
+      <p class="mcpl-muted">
+        The contract this server serves, read live from it —
+        <%= pluralize(@server.tools.size, "tool") %>, version
+        <span class="mcpl-mono"><%= @server.version %></span>.
+        Clients fetch it once, at connect time, and cache it; after a deploy that changes it,
+        reconnect the client.
+      </p>
+      <% if @server.instructions.present? %>
+        <p style="white-space: pre-line"><%= @server.instructions %></p>
+      <% end %>
+    </div>
+  </div>
+
+  <% @sections.each do |section| %>
+    <div class="mcpl-panel">
+      <h2><%= section.title %></h2>
+      <div class="mcpl-panel-body">
+        <% section.tools.each do |tool| %>
+          <div class="mcpl-tool">
+            <h3><%= tool.name %></h3>
+            <p class="mcpl-muted">
+              <% count = @counts[tool.name].to_i %>
+              <% if count.zero? %>
+                Never called.
+              <% else %>
+                <%= link_to pluralize(count, "call"), mcp_logs.calls_path(tool: tool.name) %>
+              <% end %>
+            </p>
+            <p><%= tool.description %></p>
+
+            <% if tool.params.empty? %>
+              <p class="mcpl-muted">No parameters.</p>
+            <% else %>
+              <table class="mcpl-table">
+                <thead>
+                  <tr>
+                    <th>Param</th>
+                    <th>Type</th>
+                    <th>Required</th>
+                    <th>Description</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <% tool.params.each do |param| %>
+                    <tr>
+                      <td class="mcpl-mono"><%= param.name %></td>
+                      <td class="mcpl-muted"><%= param.type %></td>
+                      <td class="mcpl-muted"><%= param.required ? "yes" : "—" %></td>
+                      <td><%= param.description %></td>
+                    </tr>
+                  <% end %>
+                </tbody>
+              </table>
+            <% end %>
+          </div>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
+<% end %>

data/config/routes.rb

@@ -0,0 +1,7 @@
+McpLogs::Engine.routes.draw do
+  root to: "calls#index"
+
+  resources :calls, only: [:index, :show]
+
+  get "docs", to: "docs#show", as: :docs
+end

data/db/migrate/001_create_mcp_logs_calls.rb

@@ -0,0 +1,49 @@
+class CreateMcpLogsCalls < ActiveRecord::Migration[8.0]
+  def change
+    create_table :mcp_logs_calls do |t|
+      t.string  :server_name
+      # Named rpc_method, not method: an ActiveRecord attribute called `method`
+      # shadows Object#method on every instance of this class.
+      t.string  :rpc_method, null: false
+      # limit: 255 on every string a client can influence. tool_name in
+      # particular is not validated input — mcp 1.0.0 passes params.name to the
+      # around_request hook before looking the tool up — and the calls page
+      # renders one <option> per distinct value, so an unbounded column lets one
+      # client fill the table and take the page down. McpLogs::Recorder truncates
+      # to the same width at capture time; this is the backstop, and it is why
+      # the number is a character count rather than a byte count.
+      t.string  :tool_name, limit: 255
+      t.jsonb   :arguments
+      t.jsonb   :response
+      t.string  :status, null: false, default: "running"
+      t.boolean :tool_error, null: false, default: false
+      t.boolean :cancelled, null: false, default: false
+      t.string  :error_type
+      t.text    :error_message
+      t.float   :duration_ms
+      t.string  :client_name, limit: 255
+      t.string  :client_version, limit: 255
+      t.string  :protocol_version, limit: 255
+      t.string  :session_id, limit: 255
+      t.string  :actor, limit: 255
+      t.string  :ip, limit: 255
+      t.string  :user_agent, limit: 255
+      # One flag per capped payload, not a single OR'd column: each of these is
+      # set independently, so the detail page can say which payload was capped
+      # instead of pointing at whichever one happened to render nearby.
+      t.boolean :arguments_truncated, null: false, default: false
+      t.boolean :response_truncated, null: false, default: false
+      t.boolean :error_message_truncated, null: false, default: false
+      t.datetime :started_at, null: false
+      t.datetime :completed_at
+
+      t.timestamps
+    end
+
+    add_index :mcp_logs_calls, :started_at
+    add_index :mcp_logs_calls, :rpc_method
+    add_index :mcp_logs_calls, :tool_name
+    add_index :mcp_logs_calls, :status
+    add_index :mcp_logs_calls, :session_id
+  end
+end

data/lib/generators/mcp_logs/install_generator.rb

@@ -0,0 +1,17 @@
+module McpLogs
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("templates", __dir__)
+
+    def copy_initializer
+      template "initializer.rb", "config/initializers/mcp_logs.rb"
+    end
+
+    def mount_engine
+      route 'mount McpLogs::Engine, at: "/mcp_logs"'
+    end
+
+    def copy_migrations
+      rake "mcp_logs:install:migrations"
+    end
+  end
+end