solid_log-ui 0.1.0

data/app/views/solid_log/ui/tokens/index.html.erb

@@ -0,0 +1,95 @@
+<div class="tokens-page">
+  <div class="page-header">
+    <div>
+      <h1>API Tokens</h1>
+      <p class="subtitle">Manage authentication tokens for log ingestion</p>
+    </div>
+    <div class="page-actions">
+      <%= link_to "Create Token", new_token_path, class: "btn btn-primary" %>
+      <%= link_to "← Dashboard", dashboard_path, class: "btn btn-secondary" %>
+    </div>
+  </div>
+
+  <div class="tokens-container">
+    <% if flash[:token_plaintext].present? %>
+      <div class="alert alert-success">
+        <h3>Token Created Successfully!</h3>
+        <p><strong>IMPORTANT:</strong> This is the only time you'll see this token. Copy it now!</p>
+        <div class="token-display">
+          <code><%= flash[:token_plaintext] %></code>
+          <button onclick="copyToken('<%= flash[:token_plaintext] %>')" class="btn btn-secondary btn-small">
+            Copy
+          </button>
+        </div>
+        <p class="token-usage">
+          Use in Authorization header: <code>Bearer <%= flash[:token_plaintext] %></code>
+        </p>
+      </div>
+    <% end %>
+
+    <% if @tokens.empty? %>
+      <div class="empty-state-large">
+        <h2>No API tokens yet</h2>
+        <p>Create a token to start ingesting logs via the HTTP API.</p>
+        <%= link_to "Create Your First Token", new_token_path, class: "btn btn-primary" %>
+      </div>
+    <% else %>
+      <div class="card">
+        <div class="card-header">
+          <h2>Active Tokens</h2>
+        </div>
+        <div class="card-body no-padding">
+          <div class="table-responsive">
+            <table class="data-table">
+              <thead>
+                <tr>
+                  <th>Name</th>
+                  <th>Created</th>
+                  <th>Last Used</th>
+                  <th>Actions</th>
+                </tr>
+              </thead>
+              <tbody>
+                <% @tokens.each do |token| %>
+                  <tr>
+                    <td class="token-name"><%= token.name %></td>
+                    <td><%= time_ago_in_words(token.created_at) %> ago</td>
+                    <td>
+                      <% if token.last_used_at %>
+                        <%= time_ago_in_words(token.last_used_at) %> ago
+                      <% else %>
+                        <span class="text-muted">Never</span>
+                      <% end %>
+                    </td>
+                    <td class="table-actions">
+                      <%= button_to "Revoke", token_path(token), method: :delete,
+                          data: { confirm: "Revoke token '#{token.name}'? This cannot be undone." },
+                          class: "btn-link-small text-danger" %>
+                    </td>
+                  </tr>
+                <% end %>
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    <% end %>
+
+    <div class="token-help">
+      <h3>Using API Tokens</h3>
+      <p>Include the token in the Authorization header of your HTTP requests:</p>
+      <pre class="code-example">curl -X POST <%= request.base_url %>/api/v1/ingest \
+  -H "Authorization: Bearer YOUR_TOKEN_HERE" \
+  -H "Content-Type: application/json" \
+  -d '{"message":"Test log","level":"info"}'</pre>
+    </div>
+  </div>
+</div>
+
+<script>
+function copyToken(token) {
+  navigator.clipboard.writeText(token).then(() => {
+    alert('Token copied to clipboard!');
+  });
+}
+</script>

data/app/views/solid_log/ui/tokens/new.html.erb

@@ -0,0 +1,47 @@
+<div class="tokens-page">
+  <div class="page-header">
+    <div>
+      <h1>Create API Token</h1>
+      <p class="subtitle">Generate a new token for log ingestion</p>
+    </div>
+    <div class="page-actions">
+      <%= link_to "← Back", tokens_path, class: "btn btn-secondary" %>
+    </div>
+  </div>
+
+  <div class="form-container">
+    <div class="card">
+      <div class="card-header">
+        <h2>Token Details</h2>
+      </div>
+      <div class="card-body">
+        <%= form_with model: @token, url: tokens_path, class: "form" do |f| %>
+          <div class="form-group">
+            <%= f.label :name, "Token Name" %>
+            <%= f.text_field :name,
+                placeholder: "e.g., Production API, Staging Server",
+                class: "form-input",
+                required: true,
+                autofocus: true %>
+            <p class="form-help">Choose a descriptive name to identify this token.</p>
+          </div>
+
+          <div class="form-actions">
+            <%= f.submit "Create Token", class: "btn btn-primary" %>
+            <%= link_to "Cancel", tokens_path, class: "btn btn-secondary" %>
+          </div>
+        <% end %>
+      </div>
+    </div>
+
+    <div class="info-card">
+      <h3>Important Information</h3>
+      <ul>
+        <li>The token will only be displayed <strong>once</strong> after creation</li>
+        <li>Store it securely - it cannot be retrieved later</li>
+        <li>Tokens can be revoked at any time from the tokens list</li>
+        <li>Each token is hashed and stored securely</li>
+      </ul>
+    </div>
+  </div>
+</div>

data/config/importmap.rb

@@ -0,0 +1,15 @@
+# Pin npm packages for SolidLog UI engine
+
+pin "application", to: "application.js"
+pin "@hotwired/turbo-rails", to: "turbo.min.js", preload: true
+pin "@rails/actioncable", to: "actioncable.esm.js"
+
+# Pin SolidLog UI JavaScript modules
+pin "solid_log/stream_scroll", to: "solid_log/stream_scroll.js"
+pin "solid_log/live_tail", to: "solid_log/live_tail.js"
+pin "solid_log/jump_to_live", to: "solid_log/jump_to_live.js"
+pin "solid_log/checkbox_dropdown", to: "solid_log/checkbox_dropdown.js"
+pin "solid_log/timeline_histogram", to: "solid_log/timeline_histogram.js"
+pin "solid_log/log_filters", to: "solid_log/log_filters.js"
+pin "solid_log/filter_state", to: "solid_log/filter_state.js"
+pin "solid_log/toast", to: "solid_log/toast.js"

data/config/routes.rb

@@ -0,0 +1,27 @@
+SolidLog::UI::Engine.routes.draw do
+  # Root - redirect to streams
+  root to: redirect("/logs/streams")
+
+  # Dashboard
+  get "dashboard", to: "dashboard#index"
+
+  # Main log viewing
+  resources :streams, only: [:index]
+  resources :entries, only: [:index, :show]
+
+  # Timeline routes for correlation
+  get "timelines/request/:request_id", to: "timelines#show_request", as: :request_timeline
+  get "timelines/job/:job_id", to: "timelines#show_job", as: :job_timeline
+
+  # Field management
+  resources :fields, only: [:index, :destroy] do
+    member do
+      post :promote
+      post :demote
+      patch :update_filter_type
+    end
+  end
+
+  # Token management
+  resources :tokens, only: [:index, :new, :create, :destroy]
+end

data/lib/solid_log/ui/api_client.rb

@@ -0,0 +1,117 @@
+require "net/http"
+require "json"
+require "uri"
+
+module SolidLog
+  module UI
+    class ApiClient
+      attr_reader :base_url, :token
+
+      def initialize(base_url: nil, token: nil)
+        @base_url = base_url || SolidLog::UI.configuration.service_url
+        @token = token || SolidLog::UI.configuration.service_token
+
+        raise ArgumentError, "base_url required for API client" if @base_url.blank?
+        raise ArgumentError, "token required for API client" if @token.blank?
+      end
+
+      # GET /api/v1/entries
+      def entries(params = {})
+        get("/api/v1/entries", params)
+      end
+
+      # GET /api/v1/entries/:id
+      def entry(id)
+        get("/api/v1/entries/#{id}")
+      end
+
+      # POST /api/v1/search
+      def search(query, params = {})
+        post("/api/v1/search", { q: query }.merge(params))
+      end
+
+      # GET /api/v1/facets
+      def facets(field)
+        get("/api/v1/facets", { field: field })
+      end
+
+      # GET /api/v1/facets/all
+      def all_facets
+        get("/api/v1/facets/all")
+      end
+
+      # GET /api/v1/timelines/request/:request_id
+      def request_timeline(request_id)
+        get("/api/v1/timelines/request/#{request_id}")
+      end
+
+      # GET /api/v1/timelines/job/:job_id
+      def job_timeline(job_id)
+        get("/api/v1/timelines/job/#{job_id}")
+      end
+
+      # GET /api/v1/health
+      def health
+        get("/api/v1/health")
+      end
+
+      private
+
+      def get(path, params = {})
+        uri = URI.parse("#{@base_url}#{path}")
+        uri.query = URI.encode_www_form(params) if params.any?
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Bearer #{@token}"
+        request["Content-Type"] = "application/json"
+
+        perform_request(uri, request)
+      end
+
+      def post(path, body = {})
+        uri = URI.parse("#{@base_url}#{path}")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{@token}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(body)
+
+        perform_request(uri, request)
+      end
+
+      def perform_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = 5
+        http.read_timeout = 30
+
+        response = http.request(request)
+
+        case response.code.to_i
+        when 200..299
+          JSON.parse(response.body)
+        when 404
+          raise NotFoundError, "Resource not found: #{uri.path}"
+        when 401
+          raise AuthenticationError, "Authentication failed. Check your service_token."
+        when 500..599
+          raise ServerError, "Server error (#{response.code}): #{response.body}"
+        else
+          raise RequestError, "Request failed (#{response.code}): #{response.body}"
+        end
+      rescue JSON::ParserError => e
+        raise ParseError, "Failed to parse JSON response: #{e.message}"
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
+        raise ConnectionError, "Cannot connect to service at #{@base_url}: #{e.message}"
+      end
+
+      # Custom errors
+      class RequestError < StandardError; end
+      class NotFoundError < RequestError; end
+      class AuthenticationError < RequestError; end
+      class ServerError < RequestError; end
+      class ConnectionError < RequestError; end
+      class ParseError < RequestError; end
+    end
+  end
+end

data/lib/solid_log/ui/configuration.rb

@@ -0,0 +1,99 @@
+module SolidLog
+  module UI
+    class Configuration
+      attr_accessor :mode,
+                    :service_url,
+                    :service_token,
+                    :database_path,
+                    :websocket_enabled,
+                    :stream_view_style,
+                    :facet_cache_ttl,
+                    :per_page,
+                    :base_controller
+      attr_reader :authentication_method
+
+      def initialize
+        # Mode: :direct_db (same database) or :http_api (remote service)
+        @mode = :direct_db
+
+        # HTTP API mode settings
+        @service_url = nil
+        @service_token = nil
+
+        # Direct DB mode settings
+        @database_path = nil
+
+        # Controller inheritance - defaults to ActionController::Base
+        # Set to "ApplicationController" or your app's base controller
+        @base_controller = "ActionController::Base"
+
+        # UI settings
+        # Authentication: :none, :basic, or a Proc/Symbol/String
+        # - :none - no authentication required
+        # - :basic - HTTP basic authentication (uses authenticate_with_basic_auth)
+        # - Proc/Lambda - custom authentication logic (called in controller context)
+        # - Symbol/String - method name to call on the controller
+        @authentication_method = :none
+        @websocket_enabled = true
+        @stream_view_style = :compact  # :compact or :expanded
+        @facet_cache_ttl = 1.minute
+        @per_page = 100
+      end
+
+      # Set authentication method with validation
+      def authentication_method=(value)
+        case value
+        when :none, :basic
+          @authentication_method = value
+        when Proc
+          @authentication_method = value
+        when Symbol, String
+          @authentication_method = value.to_sym
+        else
+          raise ArgumentError, "authentication_method must be :none, :basic, a Proc, or a Symbol/String method name"
+        end
+      end
+
+      # Check if authentication is a proc
+      def authentication_proc?
+        authentication_method.is_a?(Proc)
+      end
+
+      # Check if authentication is a method name
+      def authentication_method_name?
+        authentication_method.is_a?(Symbol) && ![:none, :basic].include?(authentication_method)
+      end
+
+      # Validate configuration
+      def valid?
+        errors = []
+
+        case mode
+        when :direct_db
+          # Direct DB mode doesn't require additional config (uses core's connection)
+        when :http_api
+          errors << "service_url required for http_api mode" if service_url.blank?
+          errors << "service_token required for http_api mode" if service_token.blank?
+        else
+          errors << "mode must be :direct_db or :http_api"
+        end
+
+        # Authentication validation is handled by the setter
+
+        if errors.any?
+          raise ArgumentError, "Invalid UI configuration:\n  #{errors.join("\n  ")}"
+        end
+
+        true
+      end
+
+      def direct_db_mode?
+        mode == :direct_db
+      end
+
+      def http_api_mode?
+        mode == :http_api
+      end
+    end
+  end
+end

data/lib/solid_log/ui/data_source.rb

@@ -0,0 +1,146 @@
+require_relative "api_client"
+
+module SolidLog
+  module UI
+    class DataSource
+      # Query entries with filters
+      def entries(filters = {})
+        if direct_db_mode?
+          query_direct_db(filters)
+        else
+          query_http_api(filters)
+        end
+      end
+
+      # Get single entry by ID
+      def entry(id)
+        if direct_db_mode?
+          SolidLog::Entry.find(id)
+        else
+          result = api_client.entry(id)
+          OpenStruct.new(result["entry"])
+        end
+      end
+
+      # Full-text search
+      def search(query, filters = {})
+        if direct_db_mode?
+          entries = SolidLog::SearchService.search(query)
+          apply_filters(entries, filters)
+        else
+          result = api_client.search(query, filters)
+          parse_entries_response(result)
+        end
+      end
+
+      # Get facets for a field
+      def facets(field)
+        if direct_db_mode?
+          SolidLog::SearchService.facets_for(field)
+        else
+          result = api_client.facets(field)
+          result["values"]
+        end
+      end
+
+      # Get all facets
+      def all_facets
+        if direct_db_mode?
+          {
+            level: SolidLog::SearchService.facets_for("level"),
+            app: SolidLog::SearchService.facets_for("app"),
+            env: SolidLog::SearchService.facets_for("env"),
+            controller: SolidLog::SearchService.facets_for("controller"),
+            action: SolidLog::SearchService.facets_for("action"),
+            method: SolidLog::SearchService.facets_for("method"),
+            status_code: SolidLog::SearchService.facets_for("status_code")
+          }
+        else
+          result = api_client.all_facets
+          result["facets"]
+        end
+      end
+
+      # Get request timeline
+      def request_timeline(request_id)
+        if direct_db_mode?
+          {
+            request_id: request_id,
+            entries: SolidLog::CorrelationService.request_timeline(request_id),
+            stats: SolidLog::CorrelationService.request_stats(request_id)
+          }
+        else
+          api_client.request_timeline(request_id)
+        end
+      end
+
+      # Get job timeline
+      def job_timeline(job_id)
+        if direct_db_mode?
+          {
+            job_id: job_id,
+            entries: SolidLog::CorrelationService.job_timeline(job_id),
+            stats: SolidLog::CorrelationService.job_stats(job_id)
+          }
+        else
+          api_client.job_timeline(job_id)
+        end
+      end
+
+      # Get health metrics
+      def health
+        if direct_db_mode?
+          SolidLog::HealthService.metrics
+        else
+          api_client.health["metrics"]
+        end
+      end
+
+      private
+
+      def direct_db_mode?
+        SolidLog::UI.configuration.direct_db_mode?
+      end
+
+      def http_api_mode?
+        SolidLog::UI.configuration.http_api_mode?
+      end
+
+      def api_client
+        @api_client ||= ApiClient.new
+      end
+
+      def query_direct_db(filters)
+        SolidLog::SearchService.query(filters).recent.limit(per_page)
+      end
+
+      def query_http_api(filters)
+        result = api_client.entries(filters.merge(limit: per_page))
+        parse_entries_response(result)
+      end
+
+      def apply_filters(scope, filters)
+        scope = scope.by_level(filters[:level]) if filters[:level].present?
+        scope = scope.by_app(filters[:app]) if filters[:app].present?
+        scope = scope.by_env(filters[:env]) if filters[:env].present?
+        scope = scope.by_controller(filters[:controller]) if filters[:controller].present?
+        scope = scope.by_action(filters[:action]) if filters[:action].present?
+        scope = scope.by_path(filters[:path]) if filters[:path].present?
+        scope = scope.by_method(filters[:method]) if filters[:method].present?
+        scope = scope.by_status_code(filters[:status_code]) if filters[:status_code].present?
+
+        scope.recent.limit(per_page)
+      end
+
+      def parse_entries_response(result)
+        # Convert API response to array of OpenStruct objects
+        # This makes them compatible with views that expect ActiveRecord objects
+        (result["entries"] || []).map { |entry| OpenStruct.new(entry) }
+      end
+
+      def per_page
+        SolidLog::UI.configuration.per_page
+      end
+    end
+  end
+end

data/lib/solid_log/ui/engine.rb

@@ -0,0 +1,76 @@
+require "importmap-rails"
+require "turbo-rails"
+require "stimulus-rails"
+
+module SolidLog
+  module UI
+    class Engine < ::Rails::Engine
+      isolate_namespace SolidLog::UI
+
+      config.generators do |g|
+        g.test_framework :test_unit
+        g.assets false
+        g.helper false
+      end
+
+      # Configure assets (works with both Sprockets and Propshaft)
+      initializer "solid_log_ui.assets" do |app|
+        # Add asset paths for both Sprockets and Propshaft
+        if app.config.respond_to?(:assets)
+          # Sprockets
+          app.config.assets.paths << root.join("app/assets/stylesheets")
+          app.config.assets.paths << root.join("app/assets/javascripts")
+          app.config.assets.paths << root.join("app/assets/images")
+
+          app.config.assets.precompile += %w[
+            solid_log/**/*.css
+            solid_log/**/*.js
+          ]
+        end
+
+        # Propshaft
+        if Rails.application.config.respond_to?(:assets) && Rails.application.config.assets.respond_to?(:paths)
+          Rails.application.config.assets.paths << root.join("app/assets/stylesheets")
+          Rails.application.config.assets.paths << root.join("app/assets/javascripts")
+          Rails.application.config.assets.paths << root.join("app/assets/images")
+        end
+      end
+
+      # Configure importmap for the engine
+      initializer "solid_log_ui.importmap", before: "importmap" do |app|
+        app.config.importmap.paths << root.join("config/importmap.rb")
+        app.config.importmap.cache_sweepers << root.join("app/assets/javascripts")
+      end
+
+      # Set up inflections for UI acronym
+      initializer "solid_log_ui.inflections" do
+        ActiveSupport::Inflector.inflections(:en) do |inflect|
+          inflect.acronym "UI"
+        end
+      end
+
+      # Load configuration if it exists
+      initializer "solid_log_ui.load_config" do
+        config_file = Rails.root.join("config/initializers/solid_log_ui.rb")
+        load config_file if File.exist?(config_file)
+      end
+
+      # Add SilenceMiddleware to main app's middleware stack
+      # This prevents the UI from logging its own queries/requests
+      initializer "solid_log_ui.add_middleware" do |app|
+        app.middleware.use SolidLog::SilenceMiddleware
+      end
+
+      # Register Action Cable channels
+      initializer "solid_log_ui.action_cable" do
+        engine_root = root
+        config.to_prepare do
+          # Ensure channel classes are loaded and available to ActionCable
+          Dir[engine_root.join("app/channels/**/*_channel.rb")].each do |file|
+            require_dependency file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solid_log/ui/version.rb

@@ -0,0 +1,5 @@
+module SolidLog
+  module UI
+    VERSION = "0.1.0"
+  end
+end

data/lib/solid_log/ui.rb

@@ -0,0 +1,27 @@
+require "solid_log/core"
+require_relative "ui/version"
+require_relative "ui/configuration"
+require_relative "ui/data_source"
+require_relative "ui/api_client"
+require_relative "ui/engine" if defined?(Rails)
+
+module SolidLog
+  module UI
+    class << self
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+        configuration.valid?
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+    end
+  end
+end

data/lib/solid_log-ui.rb

@@ -0,0 +1,2 @@
+# Top-level require for solid_log-ui gem
+require "solid_log/ui"