solid_log-ui 0.1.0

data/app/assets/stylesheets/solid_log/mission_control.css

@@ -0,0 +1,398 @@
+/* SolidLog - Mission Control Inspired Styles */
+
+:root {
+  --color-primary: #2563eb;
+  --color-success: #10b981;
+  --color-warning: #f59e0b;
+  --color-danger: #ef4444;
+  --color-info: #3b82f6;
+
+  --color-gray-50: #f9fafb;
+  --color-gray-100: #f3f4f6;
+  --color-gray-200: #e5e7eb;
+  --color-gray-300: #d1d5db;
+  --color-gray-700: #374151;
+  --color-gray-800: #1f2937;
+  --color-gray-900: #111827;
+
+  --spacing-sm: 0.5rem;
+  --spacing-md: 1rem;
+  --spacing-lg: 1.5rem;
+  --spacing-xl: 2rem;
+
+  --border-radius: 0.375rem;
+  --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+  --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--color-gray-900);
+  background: var(--color-gray-50);
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  min-height: 100vh;
+}
+
+/* Navigation */
+.top-nav {
+  background: white;
+  border-bottom: 1px solid var(--color-gray-200);
+  padding: 0 var(--spacing-xl);
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-xl);
+  height: 60px;
+}
+
+.nav-brand {
+  font-size: 1.25rem;
+}
+
+.brand-link {
+  color: var(--color-gray-900);
+  text-decoration: none;
+}
+
+.brand-link:hover {
+  color: var(--color-primary);
+}
+
+.nav-links {
+  display: flex;
+  gap: var(--spacing-md);
+}
+
+.nav-link {
+  padding: 0.5rem 1rem;
+  color: var(--color-gray-700);
+  text-decoration: none;
+  font-weight: 500;
+  border-radius: var(--border-radius);
+  transition: all 0.15s ease;
+}
+
+.nav-link:hover {
+  background: var(--color-gray-100);
+  color: var(--color-gray-900);
+}
+
+.nav-link.active {
+  background: var(--color-primary);
+  color: white;
+}
+
+/* Main Content */
+.main-content {
+  flex: 1;
+}
+
+/* Footer */
+.footer {
+  background: white;
+  border-top: 1px solid var(--color-gray-200);
+  padding: var(--spacing-md) var(--spacing-xl);
+  text-align: center;
+}
+
+.footer-content {
+  font-size: 0.75rem;
+  color: var(--color-gray-700);
+}
+
+/* Page Header */
+.page-header {
+  padding: var(--spacing-xl) var(--spacing-xl) var(--spacing-lg);
+  background: white;
+  border-bottom: 1px solid var(--color-gray-200);
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.page-header h1 {
+  margin: 0;
+  font-size: 1.875rem;
+  font-weight: 700;
+  color: var(--color-gray-900);
+}
+
+.page-header .subtitle {
+  margin: 0.25rem 0 0;
+  color: var(--color-gray-700);
+  font-size: 0.875rem;
+}
+
+.page-actions {
+  display: flex;
+  gap: var(--spacing-sm);
+}
+
+/* Dashboard */
+.dashboard {
+  max-width: 1400px;
+  margin: 0 auto;
+  padding: var(--spacing-xl);
+}
+
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+  gap: var(--spacing-lg);
+  margin-bottom: var(--spacing-xl);
+}
+
+.stat-card {
+  background: white;
+  border-radius: var(--border-radius);
+  padding: var(--spacing-lg);
+  box-shadow: var(--shadow-sm);
+  border: 1px solid var(--color-gray-200);
+}
+
+.stat-label {
+  font-size: 0.875rem;
+  color: var(--color-gray-700);
+  font-weight: 500;
+  margin-bottom: var(--spacing-sm);
+}
+
+.stat-value {
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--color-gray-900);
+  margin-bottom: var(--spacing-sm);
+}
+
+.stat-value.error-count {
+  color: var(--color-danger);
+}
+
+.stat-footer {
+  font-size: 0.75rem;
+  color: var(--color-gray-700);
+}
+
+.stat-link {
+  color: var(--color-primary);
+  text-decoration: none;
+}
+
+.stat-link:hover {
+  text-decoration: underline;
+}
+
+/* Dashboard Row */
+.dashboard-row {
+  display: grid;
+  grid-template-columns: repeat(12, 1fr);
+  gap: var(--spacing-lg);
+}
+
+.dashboard-col-8 {
+  grid-column: span 8;
+}
+
+.dashboard-col-4 {
+  grid-column: span 4;
+}
+
+@media (max-width: 768px) {
+  .dashboard-col-8,
+  .dashboard-col-4 {
+    grid-column: span 12;
+  }
+}
+
+/* Card */
+.card {
+  background: white;
+  border-radius: var(--border-radius);
+  box-shadow: var(--shadow-sm);
+  border: 1px solid var(--color-gray-200);
+  overflow: hidden;
+}
+
+.card-header {
+  padding: var(--spacing-md) var(--spacing-lg);
+  border-bottom: 1px solid var(--color-gray-200);
+  background: var(--color-gray-50);
+}
+
+.card-header h2 {
+  margin: 0;
+  font-size: 1.125rem;
+  font-weight: 600;
+  color: var(--color-gray-900);
+}
+
+.card-body {
+  padding: var(--spacing-lg);
+}
+
+.empty-state {
+  text-align: center;
+  padding: var(--spacing-xl);
+  color: var(--color-gray-700);
+}
+
+/* Log Items */
+.log-list {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-md);
+}
+
+.log-item {
+  padding: var(--spacing-md);
+  border: 1px solid var(--color-gray-200);
+  border-radius: var(--border-radius);
+  background: var(--color-gray-50);
+}
+
+.log-item-header {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+  margin-bottom: var(--spacing-sm);
+}
+
+.log-time {
+  font-size: 0.75rem;
+  color: var(--color-gray-700);
+}
+
+.log-message {
+  font-size: 0.875rem;
+  color: var(--color-gray-900);
+  margin-bottom: var(--spacing-sm);
+}
+
+.log-message a {
+  color: var(--color-gray-900);
+  text-decoration: none;
+}
+
+.log-message a:hover {
+  color: var(--color-primary);
+}
+
+.log-meta {
+  font-size: 0.75rem;
+  color: var(--color-gray-700);
+}
+
+/* Distribution */
+.distribution-list {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-md);
+}
+
+.distribution-item {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+
+.distribution-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.distribution-count {
+  font-weight: 600;
+  color: var(--color-gray-900);
+}
+
+.distribution-bar-container {
+  height: 8px;
+  background: var(--color-gray-200);
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.distribution-bar {
+  height: 100%;
+  background: var(--color-primary);
+  transition: width 0.3s ease;
+}
+
+.distribution-percentage {
+  font-size: 0.75rem;
+  color: var(--color-gray-700);
+  text-align: right;
+}
+
+/* Quick Stats */
+.quick-stats {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-md);
+}
+
+.quick-stat {
+  display: flex;
+  justify-content: space-between;
+  padding: var(--spacing-sm) 0;
+  border-bottom: 1px solid var(--color-gray-200);
+}
+
+.quick-stat:last-child {
+  border-bottom: none;
+}
+
+.quick-stat-label {
+  font-size: 0.875rem;
+  color: var(--color-gray-700);
+}
+
+.quick-stat-value {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--color-gray-900);
+}
+
+/* Recommendations */
+.recommendation-list {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-md);
+}
+
+.recommendation-item {
+  padding: var(--spacing-md);
+  background: var(--color-gray-50);
+  border: 1px solid var(--color-gray-200);
+  border-radius: var(--border-radius);
+}
+
+.recommendation-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: var(--spacing-sm);
+}
+
+.recommendation-header code {
+  font-family: "SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, monospace;
+  font-size: 0.875rem;
+  font-weight: 600;
+}
+
+.recommendation-meta {
+  font-size: 0.8125rem;
+  color: var(--color-gray-600);
+  margin-bottom: var(--spacing-sm);
+}
+
+.recommendation-action {
+  font-size: 0.875rem;
+  color: var(--color-gray-700);
+  line-height: 1.5;
+}

data/app/channels/solid_log/ui/application_cable/channel.rb

@@ -0,0 +1,8 @@
+module SolidLog
+  module UI
+    module ApplicationCable
+      class Channel < ActionCable::Channel::Base
+      end
+    end
+  end
+end

data/app/channels/solid_log/ui/application_cable/connection.rb

@@ -0,0 +1,10 @@
+module SolidLog
+  module UI
+    module ApplicationCable
+      class Connection < ActionCable::Connection::Base
+        # No authentication needed for log streaming
+        # In production, you might want to add token-based auth
+      end
+    end
+  end
+end

data/app/channels/solid_log/ui/log_stream_channel.rb

@@ -0,0 +1,132 @@
+module SolidLog
+  module UI
+    class LogStreamChannel < ApplicationCable::Channel
+    CACHE_NAMESPACE = "solid_log:active_filters"
+    CACHE_EXPIRY = 5.minutes
+
+    def subscribed
+      # Store the filters for this subscription
+      @filters = params[:filters] || {}
+      @filter_key = generate_filter_key(@filters)
+
+      # Subscribe to new entries broadcast from service
+      # Service broadcasts entry IDs, we filter and render them
+      stream_from "solid_log_new_entries", coder: ActiveSupport::JSON do |data|
+        handle_new_entries(data["entry_ids"]) if data["entry_ids"]
+      end
+
+      # Register this filter combination in Rails.cache
+      # Expires after 5 minutes of inactivity (refreshed on heartbeat)
+      cache_key = "#{CACHE_NAMESPACE}:#{@filter_key}"
+      Rails.cache.write(cache_key, @filters, expires_in: CACHE_EXPIRY)
+
+      # Also add to the set of active filter keys
+      register_active_filter_key(@filter_key)
+    end
+
+    def unsubscribed
+      # Cleanup when channel is unsubscribed
+      stop_all_streams
+
+      # Cache entries will expire naturally after CACHE_EXPIRY
+      # This handles the case where multiple clients use same filters
+    end
+
+    def refresh_subscription
+      # Called periodically by client to keep subscription active in cache
+      # This prevents the filter from expiring while user is actively watching
+      if @filter_key
+        cache_key = "#{CACHE_NAMESPACE}:#{@filter_key}"
+        Rails.cache.write(cache_key, @filters, expires_in: CACHE_EXPIRY)
+        register_active_filter_key(@filter_key)
+      end
+    end
+
+    def self.active_filter_combinations
+      # Read all active filter combinations from cache
+      active_keys = Rails.cache.read("#{CACHE_NAMESPACE}:keys") || []
+
+      filters_hash = {}
+      active_keys.each do |key|
+        cache_key = "#{CACHE_NAMESPACE}:#{key}"
+        filters = Rails.cache.read(cache_key)
+        filters_hash[key] = filters if filters
+      end
+
+      filters_hash
+    end
+
+    private
+
+    def generate_filter_key(filters)
+      # Create a consistent hash based on filter values
+      # Sort to ensure same filters = same key regardless of order
+      normalized = filters.sort.to_h
+      Digest::MD5.hexdigest(normalized.to_json)
+    end
+
+    def register_active_filter_key(filter_key)
+      # Maintain a list of active filter keys in cache
+      keys_cache_key = "#{CACHE_NAMESPACE}:keys"
+
+      # Read current keys, add this one, write back
+      # Note: This has a race condition but it's acceptable for this use case
+      current_keys = Rails.cache.read(keys_cache_key) || []
+      current_keys << filter_key unless current_keys.include?(filter_key)
+
+      # Keep the list alive as long as any filter is active
+      Rails.cache.write(keys_cache_key, current_keys.uniq, expires_in: CACHE_EXPIRY)
+    end
+
+    def handle_new_entries(entry_ids)
+      return if entry_ids.blank?
+
+      Rails.logger.info "[LogStreamChannel] Received broadcast with #{entry_ids.size} entry IDs: #{entry_ids.first(5)}"
+
+      # Fetch entries matching these IDs
+      entries = SolidLog::Entry.where(id: entry_ids).order(:id)
+      Rails.logger.info "[LogStreamChannel] Found #{entries.size} entries in database"
+
+      # Filter to only entries matching this client's filters
+      transmitted_count = 0
+      entries.each do |entry|
+        matches = entry_matches_filters?(entry)
+        Rails.logger.debug "[LogStreamChannel] Entry #{entry.id} matches filters: #{matches}"
+        next unless matches
+
+        # Render HTML for this specific entry with proper route context
+        html = SolidLog::UI::BaseController.render(
+          partial: "solid_log/ui/streams/log_row",
+          locals: { entry: entry, query: nil },
+          layout: false
+        )
+
+        # Transmit to this specific client
+        transmit({ html: html, entry_id: entry.id })
+        transmitted_count += 1
+      end
+
+      Rails.logger.info "[LogStreamChannel] Transmitted #{transmitted_count} entries to client (filter: #{@filter_key})"
+    end
+
+    def entry_matches_filters?(entry)
+      return true if @filters.blank?
+
+      # Check each filter condition
+      @filters.each do |key, values|
+        values = Array(values).reject(&:blank?)
+        next if values.empty?
+
+        entry_value = entry.public_send(key) rescue nil
+        return false if entry_value.nil?
+
+        unless values.map(&:to_s).include?(entry_value.to_s)
+          return false
+        end
+      end
+
+      true
+    end
+    end
+  end
+end

data/app/controllers/solid_log/ui/base_controller.rb

@@ -0,0 +1,122 @@
+module SolidLog
+  module UI
+    # Dynamically inherit from configured base controller
+    base_controller_class = begin
+      SolidLog::UI.configuration.base_controller.constantize
+    rescue NameError
+      # Fallback to ActionController::Base if configuration not set or class doesn't exist
+      ActionController::Base
+    end
+
+    class BaseController < base_controller_class
+      include Turbo::Streams::TurboStreamsTagBuilder
+      helper Turbo::Engine.helpers
+      helper Importmap::ImportmapTagsHelper
+
+      # Explicitly include engine helpers (now that they're in correct namespace path)
+      helper SolidLog::UI::ApplicationHelper
+      helper SolidLog::UI::DashboardHelper
+      helper SolidLog::UI::EntriesHelper
+      helper SolidLog::UI::TimelineHelper
+
+      layout "solid_log/ui/application"
+
+      before_action :authenticate_user!
+      before_action :set_data_source
+
+      # Override this method in your host application to implement custom authentication
+      #
+      # Example configurations in config/initializers/solid_log_ui.rb:
+      #
+      # 1. Using a Proc/Lambda:
+      #   SolidLog::UI.configure do |config|
+      #     config.authentication_method = ->(controller) {
+      #       controller.redirect_to controller.root_path unless controller.current_user&.admin?
+      #     }
+      #   end
+      #
+      # 2. Using a method name:
+      #   SolidLog::UI.configure do |config|
+      #     config.authentication_method = :require_admin
+      #   end
+      #
+      #   class ApplicationController
+      #     def require_admin
+      #       redirect_to root_path unless current_user&.admin?
+      #     end
+      #   end
+      #
+      # 3. Using basic auth:
+      #   SolidLog::UI.configure do |config|
+      #     config.authentication_method = :basic
+      #   end
+      #
+      def authenticate_user!
+        config = SolidLog::UI.configuration
+        auth_method = config.authentication_method
+
+        case auth_method
+        when :none
+          # No authentication required
+          true
+        when :basic
+          authenticate_or_request_with_http_basic("SolidLog") do |username, password|
+            authenticate_with_basic_auth(username, password)
+          end
+        when Proc
+          # Call the proc in the controller's context
+          instance_exec(&auth_method)
+        when Symbol
+          # Call the named method on the controller
+          if respond_to?(auth_method, true)
+            send(auth_method)
+          else
+            raise NoMethodError, "Authentication method '#{auth_method}' not defined. Define it in your ApplicationController or BaseController."
+          end
+        else
+          render plain: "Invalid authentication configuration", status: :unauthorized
+          false
+        end
+      end
+
+      protected
+
+      # Override this in host app to customize basic auth credentials
+      def authenticate_with_basic_auth(username, password)
+        # Default: check Rails credentials
+        credentials = Rails.application.credentials.solidlog || {}
+        username == credentials[:username] && password == credentials[:password]
+      end
+
+      # Helper to check if user is authenticated
+      def authenticated?
+        auth_method = SolidLog::UI.configuration.authentication_method
+
+        case auth_method
+        when :none
+          true
+        when :basic
+          request.authorization.present?
+        when Proc, Symbol
+          # For custom auth (proc or method name), assume authenticated if we got this far
+          # (since authenticate_user! would have redirected/rendered if not authenticated)
+          true
+        else
+          false
+        end
+      end
+
+      # Current user - override in host app if using custom auth
+      def current_user
+        nil
+      end
+      helper_method :current_user
+
+      private
+
+      def set_data_source
+        @data_source = SolidLog::UI::DataSource.new
+      end
+    end
+  end
+end

data/app/controllers/solid_log/ui/dashboard_controller.rb

@@ -0,0 +1,32 @@
+module SolidLog
+  module UI
+    class DashboardController < BaseController
+      def index
+        @health_metrics = SolidLog.without_logging { SolidLog::HealthService.metrics }
+        @recent_errors = recent_error_entries
+        @log_level_distribution = log_level_distribution
+        @field_recommendations = field_recommendations
+      end
+
+      private
+
+      def recent_error_entries
+        SolidLog.without_logging do
+          Entry.errors.recent.limit(10)
+        end
+      end
+
+      def log_level_distribution
+        SolidLog.without_logging do
+          Entry.group(:level).count
+        end
+      end
+
+      def field_recommendations
+        SolidLog.without_logging do
+          SolidLog::FieldAnalyzer.analyze.take(5)
+        end
+      end
+    end
+  end
+end