tracebook 0.1.0 → 1.0.0

data/app/controllers/tracebook/application_controller.rb

@@ -1,4 +1,29 @@
 module Tracebook
   class ApplicationController < ActionController::Base
+    rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+    protected
+
+    def render_not_found
+      render plain: "Not Found", status: :not_found
+    end
+
+    # Returns a display name for the current user from the host app.
+    # Tries common patterns: email, name, id. Falls back to "Anonymous".
+    #
+    # @return [String]
+    def current_tracebook_user_label
+      return "Anonymous" unless respond_to?(:current_user, true) && current_user
+
+      if current_user.respond_to?(:email) && current_user.email.present?
+        current_user.email
+      elsif current_user.respond_to?(:name) && current_user.name.present?
+        current_user.name
+      elsif current_user.respond_to?(:id)
+        "User ##{current_user.id}"
+      else
+        "Anonymous"
+      end
+    end
   end
 end

data/app/controllers/tracebook/chats_controller.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module Tracebook
+  class ChatsController < ApplicationController
+    include Pagy::Method
+
+    def index
+      chat_model = Tracebook.config.chat_model
+      scope = chat_model.includes(:messages).order(updated_at: :desc)
+
+      scope = apply_filters(scope)
+
+      @pagy, @chats = pagy(:offset, scope, limit: Tracebook.config.per_page)
+      @chat_stats = preload_chat_stats(@chats)
+      @filters = filter_params
+      @actors = load_actors(chat_model)
+      @models = load_models(chat_model)
+      @kpis = calculate_kpis(chat_model)
+    end
+
+    def show
+      chat_model = Tracebook.config.chat_model
+      @chat = chat_model.includes(messages: :model).find(params[:id])
+      @messages = @chat.messages.order(created_at: :asc)
+      @costs_by_message = load_message_costs(@messages)
+      @review = ChatReview.find_or_initialize_by(chat: @chat)
+      @comments = @review.persisted? ? @review.comments.chronological : []
+      @kpis = calculate_chat_kpis(@chat)
+
+      respond_to do |format|
+        format.html
+        format.json do
+          send_data chat_as_json(@chat),
+            type: "application/json",
+            filename: "chat-#{@chat.id}.json",
+            disposition: "attachment"
+        end
+      end
+    end
+
+    def review
+      chat_model = Tracebook.config.chat_model
+      chat = chat_model.find(params[:id])
+      review = ChatReview.for_chat(chat)
+
+      review.update!(
+        **review_params,
+        reviewed_at: Time.current
+      )
+
+      redirect_to chat_path(chat), notice: "Review updated to #{review.review_state}."
+    end
+
+    private
+
+    def filter_params
+      params.fetch(:filters, {}).permit(:actor, :model, :review_state)
+    end
+
+    def apply_filters(scope)
+      filters = filter_params
+
+      if filters[:actor].present?
+        scope = scope.where(user_id: filters[:actor])
+      end
+
+      if filters[:model].present?
+        scope = scope.joins(:model).where(models: { model_id: filters[:model] })
+      end
+
+      if filters[:review_state].present?
+        if filters[:review_state] == "pending"
+          non_pending_ids = ChatReview.where(chat_type: Tracebook.config.chat_class).where.not(review_state: :pending).pluck(:chat_id)
+          scope = scope.where.not(id: non_pending_ids)
+        else
+          reviewed_chat_ids = ChatReview.where(
+            review_state: filters[:review_state],
+            chat_type: Tracebook.config.chat_class
+          ).pluck(:chat_id)
+          scope = scope.where(id: reviewed_chat_ids)
+        end
+      end
+
+      scope
+    end
+
+    def preload_chat_stats(chats)
+      chat_ids = chats.map(&:id)
+      chat_class = Tracebook.config.chat_class
+      message_class = Tracebook.config.message_class
+
+      # Preload reviews
+      reviews = ChatReview.where(chat_type: chat_class, chat_id: chat_ids).index_by(&:chat_id)
+
+      # Preload costs per chat: sum via message join
+      message_model = Tracebook.config.message_model
+      assistant_by_chat = message_model
+        .where(chat_id: chat_ids, role: "assistant")
+        .group(:chat_id)
+        .select("chat_id, COUNT(*) as msg_count, COALESCE(SUM(input_tokens), 0) as total_input, COALESCE(SUM(output_tokens), 0) as total_output")
+        .index_by { |r| r[:chat_id] }
+
+      message_table = message_model.table_name
+      costs_by_chat = MessageCost
+        .joins(
+          ActiveRecord::Base.sanitize_sql_array([
+            "INNER JOIN #{message_table} ON #{message_table}.id = tracebook_message_costs.message_id AND tracebook_message_costs.message_type = ?",
+            message_class
+          ])
+        )
+        .where(message_table => { chat_id: chat_ids })
+        .group("#{message_table}.chat_id")
+        .sum(:cost_total_cents)
+
+      chat_ids.each_with_object({}) do |cid, hash|
+        stats = assistant_by_chat[cid]
+        hash[cid] = {
+          review_state: reviews[cid]&.review_state || "pending",
+          message_count: stats&.msg_count || 0,
+          total_input: stats&.total_input || 0,
+          total_output: stats&.total_output || 0,
+          total_cost_cents: costs_by_chat[cid] || 0
+        }
+      end
+    end
+
+    def load_actors(chat_model)
+      return [] unless chat_model.column_names.include?("user_id")
+
+      user_ids = chat_model.where.not(user_id: nil).distinct.pluck(:user_id)
+      return [] if user_ids.empty?
+
+      user_class = chat_model.reflect_on_association(:user)&.klass
+      return user_ids.map { |id| [ id, id ] } unless user_class
+
+      user_class.where(id: user_ids).map { |u| [ actor_label(u), u.id ] }
+    end
+
+    def load_models(chat_model)
+      return [] unless chat_model.reflect_on_association(:model)
+
+      chat_model.joins(:model).distinct.pluck("models.model_id").sort
+    end
+
+    def actor_label(actor)
+      if Tracebook.config.actor_display
+        Tracebook.config.actor_display.call(actor)
+      else
+        actor.try(:name) || actor.try(:email) || "#{actor.class}##{actor.id}"
+      end
+    end
+
+    def calculate_kpis(chat_model)
+      message_model = Tracebook.config.message_model
+      {
+        total_chats: chat_model.count,
+        total_messages: message_model.where(role: "assistant").count,
+        total_cost_cents: MessageCost.sum(:cost_total_cents)
+      }
+    end
+
+    def review_params
+      params.permit(:review_state, :review_comment, :reviewed_by)
+    end
+
+    def load_message_costs(messages)
+      assistant_ids = messages.select { |m| m.role == "assistant" }.map(&:id)
+      return {} if assistant_ids.empty?
+
+      MessageCost.where(
+        message_type: Tracebook.config.message_class,
+        message_id: assistant_ids
+      ).index_by { |c| c.message_id.to_i }
+    end
+
+    def chat_as_json(chat)
+      messages_json = @messages.map do |message|
+        msg = {
+          role: message.role,
+          content: message.content,
+          created_at: message.created_at.iso8601
+        }
+
+        if message.role == "assistant"
+          msg[:input_tokens] = message.input_tokens
+          msg[:output_tokens] = message.output_tokens
+          msg[:model] = message.model&.model_id
+
+          cost = @costs_by_message[message.id]
+          if cost
+            msg[:cost] = {
+              input_cents: cost.cost_input_cents,
+              output_cents: cost.cost_output_cents,
+              total_cents: cost.cost_total_cents
+            }
+          end
+        end
+
+        msg
+      end
+
+      review_state = @review.persisted? ? @review.review_state : "pending"
+
+      {
+        id: chat.id,
+        actor: helpers.actor_name(chat),
+        created_at: chat.created_at.iso8601,
+        updated_at: chat.updated_at.iso8601,
+        kpis: @kpis,
+        review_state: review_state,
+        messages: messages_json
+      }.to_json
+    end
+
+    def calculate_chat_kpis(chat)
+      messages = chat.messages.where(role: "assistant")
+      message_ids = messages.pluck(:id)
+      message_type = Tracebook.config.message_class
+      costs = MessageCost.where(message_type: message_type, message_id: message_ids)
+
+      {
+        message_count: messages.count,
+        total_input_tokens: messages.sum(:input_tokens),
+        total_output_tokens: messages.sum(:output_tokens),
+        total_cost_cents: costs.sum(:cost_total_cents)
+      }
+    end
+  end
+end

data/app/controllers/tracebook/comments_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Tracebook
+  class CommentsController < ApplicationController
+    def create
+      chat = Tracebook.config.chat_model.find(params[:chat_id])
+      review = ChatReview.for_chat(chat)
+
+      comment = review.comments.build(comment_params)
+      comment.author = current_tracebook_user_label
+
+      if comment.save
+        redirect_to chat_path(chat), notice: "Comment added"
+      else
+        redirect_to chat_path(chat), alert: "Failed to add comment"
+      end
+    end
+
+    private
+
+    def comment_params
+      params.require(:comment).permit(:body)
+    end
+  end
+end

data/app/helpers/tracebook/chats_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Tracebook
+  module ChatsHelper
+    def cents_to_human(cents)
+      number_to_currency(cents.to_f / 100.0)
+    end
+
+    def review_badge(review_state)
+      css_class = case review_state.to_s
+      when "approved" then "tb-status tb-status-success"
+      when "flagged" then "tb-status tb-status-error"
+      else "tb-status tb-status-pending"
+      end
+      content_tag(:span, review_state, class: css_class)
+    end
+
+    def actor_name(chat)
+      actor = chat.try(:user)
+      return "—" unless actor
+
+      if Tracebook.config.actor_display
+        Tracebook.config.actor_display.call(actor)
+      else
+        actor.try(:name) || actor.try(:email) || "#{actor.class.name}##{actor.id}"
+      end
+    end
+  end
+end

data/app/models/tracebook/chat_review.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tracebook
+  class ChatReview < ApplicationRecord
+    self.table_name = "tracebook_chat_reviews"
+
+    belongs_to :chat, polymorphic: true, optional: true
+    has_many :comments, class_name: "Tracebook::Comment", dependent: :destroy
+
+    enum :review_state, { pending: 0, approved: 1, flagged: 2 }, prefix: true
+
+    validates :chat_type, presence: true
+    validates :chat_id, presence: true
+
+    def self.for_chat(chat)
+      find_or_create_by!(chat: chat)
+    end
+  end
+end

data/app/models/tracebook/comment.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Tracebook
+  class Comment < ApplicationRecord
+    self.table_name = "tracebook_comments"
+
+    belongs_to :chat_review, class_name: "Tracebook::ChatReview"
+
+    validates :author, presence: true
+    validates :body, presence: true
+
+    scope :chronological, -> { order(created_at: :asc) }
+  end
+end

data/app/models/tracebook/message_cost.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Tracebook
+  class MessageCost < ApplicationRecord
+    self.table_name = "tracebook_message_costs"
+
+    belongs_to :message, polymorphic: true, optional: true
+
+    validates :message_type, presence: true
+    validates :message_id, presence: true
+  end
+end

data/app/models/tracebook/pricing_rule.rb

@@ -3,14 +3,14 @@
 module Tracebook
   # Pricing rule for calculating LLM interaction costs.
   #
-  # Defines cost per 1000 tokens for a provider/model pattern. Supports
-  # glob patterns for matching multiple models and date-based effective periods.
+  # Defines cost in cents per 1,000,000 tokens for a provider/model pattern.
+  # Supports glob patterns for matching multiple models and date-based effective periods.
   #
   # ## Fields
   # - `provider` - Provider name (e.g., "openai", "anthropic")
   # - `model_glob` - Glob pattern for matching models (e.g., "gpt-4o*", "claude-3-5-*")
-  # - `input_per_1k` - Cost per 1000 input tokens
-  # - `output_per_1k` - Cost per 1000 output tokens
+  # - `input_cents_per_unit` - Cost in cents per 1M input tokens (decimal)
+  # - `output_cents_per_unit` - Cost in cents per 1M output tokens (decimal)
   # - `currency` - Currency code (e.g., "USD")
   # - `effective_from` - Date this pricing takes effect
   # - `effective_to` - Optional end date for this pricing
@@ -19,8 +19,8 @@ module Tracebook
   #   PricingRule.create!(
   #     provider: "openai",
   #     model_glob: "gpt-4o",
-  #     input_per_1k: 2.50,
-  #     output_per_1k: 10.00,
+  #     input_cents_per_unit: 250,    # $2.50/1M tokens
+  #     output_cents_per_unit: 1000,  # $10.00/1M tokens
   #     currency: "USD",
   #     effective_from: Date.new(2024, 8, 6)
   #   )
@@ -80,5 +80,3 @@ module Tracebook
     end
   end
 end
-
-TraceBook = Tracebook unless defined?(TraceBook)

data/app/views/tracebook/chats/index.html.erb

@@ -0,0 +1,77 @@
+<div class="tb-container">
+  <header class="tb-header">
+    <h1>TraceBook</h1>
+    <div class="tb-kpis">
+      <div class="tb-kpi">
+        <span>Chats</span>
+        <strong><%= number_with_delimiter(@kpis[:total_chats]) %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Messages</span>
+        <strong><%= number_with_delimiter(@kpis[:total_messages]) %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Cost</span>
+        <strong><%= cents_to_human(@kpis[:total_cost_cents]) %></strong>
+      </div>
+    </div>
+  </header>
+
+  <section class="tb-filters">
+    <%= form_with url: chats_path, method: :get, scope: :filters, class: "tb-filter-form" do |form| %>
+      <div class="tb-filter-row" style="display: flex; gap: 1rem; align-items: flex-end;">
+        <div class="tb-filter-field" style="flex: 1;">
+          <%= form.label :actor %>
+          <%= form.select :actor, options_for_select(@actors, @filters[:actor]), { include_blank: "All actors" }, style: "width: 100%;" %>
+        </div>
+        <div class="tb-filter-field" style="flex: 1;">
+          <%= form.label :model %>
+          <%= form.select :model, options_for_select(@models, @filters[:model]), { include_blank: "All models" }, style: "width: 100%;" %>
+        </div>
+        <div class="tb-filter-field" style="flex: 1;">
+          <%= form.label :review_state, "Review" %>
+          <%= form.select :review_state, options_for_select([["Pending", "pending"], ["Approved", "approved"], ["Flagged", "flagged"]], @filters[:review_state]), { include_blank: "All states" }, style: "width: 100%;" %>
+        </div>
+        <div class="tb-filter-actions" style="display: flex; gap: 0.5rem; align-items: center; white-space: nowrap; margin-left: auto;">
+          <%= form.submit "Apply" %>
+          <%= link_to "Reset", chats_path, class: "tb-link" %>
+        </div>
+      </div>
+    <% end %>
+  </section>
+
+  <section class="tb-table-wrapper">
+    <table class="tb-table">
+      <thead>
+        <tr>
+          <th>Chat</th>
+          <th>Actor</th>
+          <th>Model</th>
+          <th>Messages</th>
+          <th>Tokens</th>
+          <th>Cost</th>
+          <th>Review</th>
+          <th>Last Activity</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @chats.each do |chat| %>
+          <% stats = @chat_stats[chat.id] || {} %>
+          <tr>
+            <td data-label="Chat"><%= link_to "##{chat.id}", chat_path(chat) %></td>
+            <td data-label="Actor"><%= actor_name(chat) %></td>
+            <td data-label="Model"><%= chat.try(:model)&.try(:model_id) || "—" %></td>
+            <td data-label="Messages"><%= stats[:message_count] || 0 %></td>
+            <td data-label="Tokens"><%= number_with_delimiter(stats[:total_input] || 0) %> / <%= number_with_delimiter(stats[:total_output] || 0) %></td>
+            <td data-label="Cost"><%= cents_to_human(stats[:total_cost_cents] || 0) %></td>
+            <td data-label="Review"><%= review_badge(stats[:review_state] || "pending") %></td>
+            <td data-label="Last Activity"><%= chat.updated_at.strftime("%Y-%m-%d %H:%M") %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+    <nav class="tb-pagination" aria-label="Chats pagination">
+      <%== @pagy.series_nav %>
+    </nav>
+  </section>
+</div>

data/app/views/tracebook/chats/show.html.erb

@@ -0,0 +1,94 @@
+<div class="tb-container">
+  <header class="tb-header">
+    <h1>TraceBook</h1>
+    <div class="tb-breadcrumb">
+      <%= link_to "&larr; All Chats".html_safe, chats_path, class: "tb-back-link" %>
+      <span class="tb-muted">/ Chat #<%= @chat.id %> — <%= actor_name(@chat) %></span>
+      <%= link_to "Export JSON", chat_path(@chat, format: :json), class: "tb-export-btn" %>
+    </div>
+    <div class="tb-kpis">
+      <div class="tb-kpi">
+        <span>Messages</span>
+        <strong><%= @kpis[:message_count] %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Input Tokens</span>
+        <strong><%= number_with_delimiter(@kpis[:total_input_tokens]) %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Output Tokens</span>
+        <strong><%= number_with_delimiter(@kpis[:total_output_tokens]) %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Cost</span>
+        <strong><%= cents_to_human(@kpis[:total_cost_cents]) %></strong>
+      </div>
+    </div>
+  </header>
+
+  <section class="tb-table-wrapper">
+    <h2 class="tb-section-title">Conversation</h2>
+    <div class="tb-messages">
+      <% @messages.each do |message| %>
+        <div class="tb-message tb-message-<%= message.role %>">
+          <div class="tb-message-header">
+            <strong><%= message.role.capitalize %></strong>
+            <span class="tb-muted"><%= message.created_at.strftime("%H:%M:%S") %></span>
+            <% if message.role == "assistant" %>
+              <span class="tb-muted">
+                <%= message.input_tokens %> / <%= message.output_tokens %> tokens
+                <% cost = @costs_by_message[message.id] %>
+                <% if cost %>
+                  &middot; <%= cents_to_human(cost.cost_total_cents) %>
+                <% end %>
+              </span>
+            <% end %>
+          </div>
+          <div class="tb-message-content">
+            <%= simple_format(message.content.to_s.truncate(2000)) %>
+          </div>
+        </div>
+      <% end %>
+    </div>
+  </section>
+
+  <section class="tb-table-wrapper">
+    <h2 class="tb-section-title">Review</h2>
+
+    <% current_state = @review.persisted? ? @review.review_state : "pending" %>
+    <div class="tb-review-bar">
+      <div class="tb-review-status">
+        <span class="tb-review-status-label">Status</span>
+        <%= review_badge(current_state) %>
+      </div>
+      <%= form_with url: review_chat_path(@chat), method: :post do |f| %>
+        <div class="tb-review-actions">
+          <button type="submit" name="review_state" value="approved" class="tb-review-btn tb-review-btn-approved">Approve</button>
+          <button type="submit" name="review_state" value="flagged" class="tb-review-btn tb-review-btn-flagged">Flag</button>
+          <button type="submit" name="review_state" value="pending" class="tb-review-btn tb-review-btn-pending">Reset</button>
+        </div>
+      <% end %>
+    </div>
+
+    <% if @comments.any? %>
+      <div class="tb-review-comments">
+        <% @comments.each do |comment| %>
+          <div class="tb-review-comment">
+            <div class="tb-review-comment-meta">
+              <strong class="tb-review-comment-author"><%= comment.author %></strong>
+              <span class="tb-muted"><%= comment.created_at.strftime("%Y-%m-%d %H:%M") %></span>
+            </div>
+            <p class="tb-review-comment-body"><%= comment.body %></p>
+          </div>
+        <% end %>
+      </div>
+    <% end %>
+
+    <%= form_with url: chat_comments_path(@chat), method: :post, scope: :comment do |f| %>
+      <div class="tb-review-compose">
+        <%= f.text_area :body, placeholder: "Add a comment...", rows: 2, required: true, class: "tb-review-textarea" %>
+        <%= f.submit "Comment", class: "tb-review-submit" %>
+      </div>
+    <% end %>
+  </section>
+</div>

data/config/routes.rb

@@ -1,8 +1,10 @@
 Tracebook::Engine.routes.draw do
-  resources :interactions, only: [ :index, :show ] do
-    post :review, on: :member
-    post :bulk_review, on: :collection
-  end
+  root to: redirect("chats")
 
-  resources :exports, only: [ :create, :show ]
+  resources :chats, only: [ :index, :show ] do
+    member do
+      post :review
+    end
+    resources :comments, only: [ :create ]
+  end
 end

data/db/migrate/20260325000100_create_tracebook_message_costs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateTracebookMessageCosts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :tracebook_message_costs do |t|
+      t.string :message_type, null: false
+      t.bigint :message_id, null: false
+      t.decimal :cost_input_cents, precision: 12, scale: 4, default: 0, null: false
+      t.decimal :cost_output_cents, precision: 12, scale: 4, default: 0, null: false
+      t.decimal :cost_total_cents, precision: 12, scale: 4, default: 0, null: false
+      t.string :currency, null: false, default: "USD"
+      t.integer :latency_ms
+
+      t.timestamps
+    end
+
+    add_index :tracebook_message_costs, [ :message_type, :message_id ], unique: true, name: "index_tracebook_message_costs_on_message"
+  end
+end

data/db/migrate/20260325000200_create_tracebook_chat_reviews.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateTracebookChatReviews < ActiveRecord::Migration[8.0]
+  def change
+    create_table :tracebook_chat_reviews do |t|
+      t.string :chat_type, null: false
+      t.bigint :chat_id, null: false
+      t.integer :review_state, null: false, default: 0
+      t.text :review_comment
+      t.datetime :reviewed_at
+      t.string :reviewed_by
+
+      t.timestamps
+    end
+
+    add_index :tracebook_chat_reviews, [ :chat_type, :chat_id ], unique: true, name: "index_tracebook_chat_reviews_on_chat"
+    add_index :tracebook_chat_reviews, :review_state
+  end
+end

data/db/migrate/{20241112000300_create_tracebook_pricing_rules.rb → 20260325000300_create_tracebook_pricing_rules.rb}

@@ -5,9 +5,9 @@ class CreateTracebookPricingRules < ActiveRecord::Migration[8.0]
     create_table :tracebook_pricing_rules do |t|
       t.string :provider, null: false
       t.string :model_glob, null: false
-      t.string :unit, null: false, default: "per_1k_tokens"
-      t.integer :input_cents_per_unit, null: false, default: 0
-      t.integer :output_cents_per_unit, null: false, default: 0
+      t.string :unit, null: false, default: "per_1m_tokens"
+      t.decimal :input_cents_per_unit, precision: 10, scale: 4, null: false, default: 0
+      t.decimal :output_cents_per_unit, precision: 10, scale: 4, null: false, default: 0
       t.date :effective_from, null: false
       t.date :effective_to
       t.string :currency, null: false, default: "USD"

data/db/migrate/20260325000500_create_tracebook_comments.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class CreateTracebookComments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :tracebook_comments do |t|
+      t.references :chat_review, null: false, foreign_key: { to_table: :tracebook_chat_reviews }
+      t.string :author, null: false
+      t.text :body, null: false
+
+      t.timestamps
+    end
+
+    add_index :tracebook_comments, [ :chat_review_id, :created_at ]
+  end
+end

data/lib/generators/tracebook/install/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Install TraceBook by copying migrations and creating an initializer.
+
+Example:
+    bin/rails generate tracebook:install
+
+After running:
+    1. Run: bin/rails db:migrate
+    2. Mount the engine in config/routes.rb
+    3. Configure authorization in the initializer