solid_log-ui 0.1.0

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

@@ -0,0 +1,34 @@
+module SolidLog
+  module UI
+    class EntriesController < BaseController
+      def index
+        # Redirect to streams for better UX
+        redirect_to streams_path
+      end
+
+      def show
+        @entry = SolidLog.without_logging do
+          Entry.find(params[:id])
+        end
+
+        @correlated_entries = find_correlated_entries if @entry.correlated?
+      end
+
+      private
+
+      def find_correlated_entries
+        SolidLog.without_logging do
+          scope = Entry.where.not(id: @entry.id)
+
+          if @entry.request_id.present?
+            scope = scope.by_request_id(@entry.request_id)
+          elsif @entry.job_id.present?
+            scope = scope.by_job_id(@entry.job_id)
+          end
+
+          scope.recent.limit(50)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module SolidLog
+  module UI
+    class FieldsController < BaseController
+      def index
+        @fields = SolidLog.without_logging do
+          Field.order(usage_count: :desc)
+        end
+
+        @hot_fields = @fields.select { |f| f.usage_count >= 1000 }
+        @total_fields = @fields.size
+      end
+
+      def promote
+        @field = Field.find(params[:id])
+
+        SolidLog.without_logging do
+          @field.promote!
+        end
+
+        redirect_to fields_path, notice: "Field '#{@field.name}' marked as promoted"
+      end
+
+      def demote
+        @field = Field.find(params[:id])
+
+        SolidLog.without_logging do
+          @field.demote!
+        end
+
+        redirect_to fields_path, notice: "Field '#{@field.name}' marked as unpromoted"
+      end
+
+      def update_filter_type
+        @field = Field.find(params[:id])
+
+        SolidLog.without_logging do
+          if @field.update(filter_type: params[:field][:filter_type])
+            redirect_to fields_path, notice: "Filter type for '#{@field.name}' updated to #{@field.filter_type}"
+          else
+            redirect_to fields_path, alert: "Failed to update filter type: #{@field.errors.full_messages.join(', ')}"
+          end
+        end
+      end
+
+      def destroy
+        @field = Field.find(params[:id])
+        field_name = @field.name
+
+        SolidLog.without_logging do
+          @field.destroy
+        end
+
+        redirect_to fields_path, notice: "Field '#{field_name}' removed from registry"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+module SolidLog
+  module UI
+    class StreamsController < BaseController
+      def index
+        # Build search params with pagination
+        search_params = (params[:filters] || {}).merge(
+          before_id: params[:before_id],
+          after_id: params[:after_id],
+          limit: params[:limit] || 200
+        )
+
+        @search_service = SolidLog::Core::SearchService.new(
+          search_params,
+          facet_cache_ttl: SolidLog::UI.configuration.facet_cache_ttl
+        )
+
+        @entries = SolidLog.without_logging do
+          @search_service.search
+        end
+
+        @available_filters = SolidLog.without_logging do
+          @search_service.available_facets
+        end
+
+        @current_filters = current_filters
+
+        # Generate timeline data for visualization (skip for pagination requests unless timeline_only)
+        @timeline_data = if (params[:after_id].present? || params[:before_id].present?) && !params[:timeline_only].present?
+          { buckets: [] }
+        else
+          SolidLog.without_logging do
+            generate_timeline_data
+          end
+        end
+
+        respond_to do |format|
+          format.html
+          format.turbo_stream do
+            if params[:timeline_only].present?
+              # Timeline update during live tail
+              render turbo_stream: [
+                turbo_stream.replace("timeline-container", partial: "timeline", locals: { timeline_data: @timeline_data, current_filters: @current_filters })
+              ]
+            elsif params[:before_id].present?
+              # Infinite scroll up - prepend older entries
+              # Entries from query in DESC, partial reverses to ASC for prepending
+              if @entries.any?
+                render turbo_stream: [
+                  turbo_stream.prepend("log-stream-content", partial: "log_entries", locals: { entries: @entries, query: @current_filters[:query] })
+                ]
+              else
+                head :no_content
+              end
+            elsif params[:after_id].present?
+              # Live tail update - append new entries
+              # Entries from query in DESC, partial reverses to ASC for appending
+              if @entries.any?
+                render turbo_stream: [
+                  turbo_stream.append("log-stream-content", partial: "log_entries", locals: { entries: @entries, query: @current_filters[:query] })
+                ]
+              else
+                head :no_content
+              end
+            else
+              # Full refresh (Jump to Live or filter change)
+              render turbo_stream: [
+                turbo_stream.replace("log-stream-content", partial: "log_stream_content", locals: { entries: @entries, query: @current_filters[:query] }),
+                turbo_stream.replace("timeline-container", partial: "timeline", locals: { timeline_data: @timeline_data, current_filters: @current_filters }),
+                turbo_stream.append("toast-container", partial: "solid_log/ui/shared/toast_message", locals: { message: "Jumped to live - showing latest logs", type: "success" })
+              ]
+            end
+          end
+        end
+      end
+
+      private
+
+      def current_filters
+        filter_params = params.fetch(:filters, {})
+        filters = {
+          query: filter_params[:query],
+          levels: Array(filter_params[:levels]).reject(&:blank?),
+          app: Array(filter_params[:app]).flatten.reject(&:blank?),
+          env: Array(filter_params[:env]).flatten.reject(&:blank?),
+          controller: Array(filter_params[:controller]).flatten.reject(&:blank?),
+          action: Array(filter_params[:action]).flatten.reject(&:blank?),
+          path: Array(filter_params[:path]).flatten.reject(&:blank?),
+          method: Array(filter_params[:method]).flatten.reject(&:blank?),
+          status_code: Array(filter_params[:status_code]).flatten.reject(&:blank?),
+          min_duration: filter_params[:min_duration],
+          max_duration: filter_params[:max_duration],
+          start_time: filter_params[:start_time],
+          end_time: filter_params[:end_time],
+          request_id: filter_params[:request_id],
+          job_id: filter_params[:job_id]
+        }
+
+        # Add promoted field filters based on their filter type
+        Field.promoted.each do |field|
+          next unless Entry.column_names.include?(field.name)
+
+          case field.filter_type
+          when "multiselect"
+            filters[field.name.to_sym] = Array(filter_params[field.name.to_sym]).flatten.reject(&:blank?)
+          when "tokens"
+            # Keep as string for parsing in SearchService
+            filters[field.name.to_sym] = filter_params[field.name.to_sym]
+          when "range"
+            filters["min_#{field.name}".to_sym] = filter_params["min_#{field.name}".to_sym]
+            filters["max_#{field.name}".to_sym] = filter_params["max_#{field.name}".to_sym]
+          else
+            filters[field.name.to_sym] = filter_params[field.name.to_sym]
+          end
+        end
+
+        filters
+      end
+
+      def generate_timeline_data
+        # Get the time range for the currently displayed entries
+        return { buckets: [], start_time: nil, end_time: nil } if @entries.empty?
+
+        # Determine time range: use filter times if present, otherwise use entry times
+        # Note: entries are ordered by ID DESC (newest first when limited)
+        start_time = if @current_filters[:start_time].present?
+          Time.zone.parse(@current_filters[:start_time])
+        else
+          @entries.last.timestamp  # oldest of displayed entries
+        end
+
+        end_time = if @current_filters[:end_time].present?
+          Time.zone.parse(@current_filters[:end_time])
+        else
+          @entries.first.timestamp  # newest of displayed entries
+        end
+
+        # Calculate appropriate bucket size based on time range
+        time_range = end_time - start_time
+        bucket_count = 50 # Number of buckets to display
+
+        bucket_size = if time_range < 1.hour
+          1.minute
+        elsif time_range < 1.day
+          5.minutes
+        elsif time_range < 1.week
+          1.hour
+        else
+          6.hours
+        end
+
+        # Get all counts in a single query
+        base_scope = Entry.all.yield_self { |scope| apply_current_filters_to_scope(scope) }
+        start_epoch = start_time.to_i
+        epoch_sql = SolidLog.adapter.timestamp_to_epoch_sql("timestamp")
+        bucket_calculation = "((#{epoch_sql} - #{start_epoch}) / #{bucket_size.to_i})"
+
+        # Single query with GROUP BY bucket
+        bucket_counts = base_scope
+          .where(timestamp: start_time..end_time)
+          .group(Arel.sql(bucket_calculation))
+          .order(Arel.sql(bucket_calculation))
+          .pluck(Arel.sql(bucket_calculation), Arel.sql("COUNT(*)"))
+          .to_h
+
+        # Generate buckets with counts from the hash
+        buckets = []
+        current_time = start_time
+        bucket_count.times do |bucket_num|
+          bucket_end = current_time + bucket_size
+
+          buckets << {
+            start_time: current_time,
+            end_time: bucket_end,
+            count: bucket_counts[bucket_num] || 0
+          }
+
+          current_time = bucket_end
+        end
+
+        {
+          buckets: buckets,
+          start_time: start_time,
+          end_time: end_time,
+          bucket_size: bucket_size
+        }
+      end
+
+      def apply_current_filters_to_scope(scope)
+        # Apply the same filters as SearchService to get accurate counts
+        scope = scope.where(level: @current_filters[:levels]) if @current_filters[:levels].any?
+        scope = scope.by_app(@current_filters[:app]) if @current_filters[:app].any?
+        scope = scope.by_env(@current_filters[:env]) if @current_filters[:env].any?
+        scope = scope.by_controller(@current_filters[:controller]) if @current_filters[:controller].any?
+        scope = scope.by_action(@current_filters[:action]) if @current_filters[:action].any?
+        scope = scope.by_path(@current_filters[:path]) if @current_filters[:path].any?
+        scope = scope.by_method(@current_filters[:method]) if @current_filters[:method].any?
+        scope = scope.by_status_code(@current_filters[:status_code]) if @current_filters[:status_code].any?
+        scope = scope.by_request_id(@current_filters[:request_id]) if @current_filters[:request_id].present?
+        scope = scope.by_job_id(@current_filters[:job_id]) if @current_filters[:job_id].present?
+        scope
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module SolidLog
+  module UI
+    class TimelinesController < BaseController
+      def show_request
+        @request_id = params[:request_id]
+
+        @entries = SolidLog.without_logging do
+          Entry.by_request_id(@request_id).recent
+        end
+
+        if @entries.empty?
+          redirect_to streams_path, alert: "No entries found for request ID: #{@request_id}"
+        end
+      end
+
+      def show_job
+        @job_id = params[:job_id]
+
+        @entries = SolidLog.without_logging do
+          Entry.by_job_id(@job_id).recent
+        end
+
+        if @entries.empty?
+          redirect_to streams_path, alert: "No entries found for job ID: #{@job_id}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module SolidLog
+  module UI
+    class TokensController < BaseController
+      def index
+        @tokens = SolidLog.without_logging do
+          Token.order(created_at: :desc)
+        end
+      end
+
+      def new
+        @token = Token.new
+      end
+
+      def create
+        @token = SolidLog.without_logging do
+          Token.generate!(token_params[:name])
+        end
+
+        # Store plaintext token in flash for one-time display
+        flash[:token_plaintext] = @token[:token]
+        redirect_to tokens_path, notice: "Token created successfully"
+      rescue ActiveRecord::RecordInvalid => e
+        @token = Token.new(token_params)
+        flash.now[:alert] = "Failed to create token: #{e.message}"
+        render :new, status: :unprocessable_entity
+      end
+
+      def destroy
+        @token = Token.find(params[:id])
+        token_name = @token.name
+
+        SolidLog.without_logging do
+          @token.destroy
+        end
+
+        redirect_to tokens_path, notice: "Token '#{token_name}' revoked"
+      end
+
+      private
+
+      def token_params
+        params.require(:token).permit(:name)
+      end
+    end
+  end
+end

data/app/helpers/solid_log/ui/application_helper.rb

@@ -0,0 +1,99 @@
+module SolidLog
+  module UI
+    module ApplicationHelper
+      # Navigation helpers
+      def nav_link_class(path)
+        base_class = "nav-link"
+        current_path = request.path
+
+        # Check if we're on this path or a sub-path
+        active = if path == root_path
+          current_path == path || current_path == dashboard_path
+        else
+          current_path.start_with?(path)
+        end
+
+        active ? "#{base_class} active" : base_class
+      end
+
+      # Log display helpers (shared across views)
+      def level_badge(level)
+        badge_class = case level.to_s.downcase
+        when "debug"
+          "badge-gray"
+        when "info"
+          "badge-blue"
+        when "warn"
+          "badge-yellow"
+        when "error"
+          "badge-red"
+        when "fatal"
+          "badge-dark-red"
+        else
+          "badge-secondary"
+        end
+
+        content_tag(:span, level.upcase, class: "badge #{badge_class}")
+      end
+
+      def http_status_badge(status_code)
+        return "" if status_code.blank?
+
+        badge_class = case status_code
+        when 200..299
+          "badge-success"
+        when 300..399
+          "badge-info"
+        when 400..499
+          "badge-warning"
+        when 500..599
+          "badge-danger"
+        else
+          "badge-secondary"
+        end
+
+        content_tag(:span, status_code, class: "badge #{badge_class}")
+      end
+
+      def format_duration(duration_ms)
+        return "" if duration_ms.blank?
+
+        if duration_ms < 1000
+          format("%.1fms", duration_ms)
+        else
+          format("%.1fs", duration_ms / 1000.0)
+        end
+      end
+
+      def truncate_message(message, length: 200)
+        return "" if message.blank?
+
+        truncate(message, length: length, separator: " ")
+      end
+
+      def highlight_search_term(text, query)
+        return text if query.blank? || text.blank?
+
+        highlight(text, query, highlighter: '<mark>\1</mark>')
+      end
+
+      def correlation_link(entry)
+        links = []
+
+        if entry.request_id.present?
+          links << link_to("Request: #{entry.request_id[0..7]}",
+                          request_timeline_path(entry.request_id),
+                          class: "correlation-link")
+        end
+
+        if entry.job_id.present?
+          links << link_to("Job: #{entry.job_id[0..7]}",
+                          job_timeline_path(entry.job_id),
+                          class: "correlation-link")
+        end
+
+        safe_join(links, " ")
+      end
+    end
+  end
+end

data/app/helpers/solid_log/ui/dashboard_helper.rb

@@ -0,0 +1,46 @@
+module SolidLog
+  module UI
+    module DashboardHelper
+      def format_count(count)
+        number_with_delimiter(count || 0)
+      end
+
+      def format_percentage(numerator, denominator)
+        return "0%" if denominator.nil? || denominator.zero?
+
+        percentage = (numerator.to_f / denominator * 100).round(1)
+        "#{percentage}%"
+      end
+
+      def trend_indicator(current, previous)
+        return "" if previous.nil? || previous.zero?
+
+        change = ((current - previous).to_f / previous * 100).round(1)
+
+        if change > 0
+          content_tag(:span, "+#{change}%", class: "trend-up")
+        elsif change < 0
+          content_tag(:span, "#{change}%", class: "trend-down")
+        else
+          content_tag(:span, "0%", class: "trend-neutral")
+        end
+      end
+
+      def time_ago_or_never(time)
+        time ? time_ago_in_words(time) + " ago" : "Never"
+      end
+
+      def health_status_badge(unparsed_count)
+        if unparsed_count == 0
+          content_tag(:span, "Healthy", class: "badge badge-success")
+        elsif unparsed_count < 100
+          content_tag(:span, "OK", class: "badge badge-info")
+        elsif unparsed_count < 1000
+          content_tag(:span, "Warning", class: "badge badge-warning")
+        else
+          content_tag(:span, "Backlog", class: "badge badge-danger")
+        end
+      end
+    end
+  end
+end

data/app/helpers/solid_log/ui/entries_helper.rb

@@ -0,0 +1,16 @@
+module SolidLog
+  module UI
+    module EntriesHelper
+      # Entry-specific helpers (not shared across other controllers)
+
+      def pretty_json(json_string)
+        return "" if json_string.blank?
+
+        hash = JSON.parse(json_string)
+        JSON.pretty_generate(hash)
+      rescue JSON::ParserError
+        json_string
+      end
+    end
+  end
+end

data/app/helpers/solid_log/ui/timeline_helper.rb

@@ -0,0 +1,39 @@
+module SolidLog
+  module UI
+    module TimelineHelper
+      def timeline_duration_bar(duration, max_duration)
+        return "" if duration.nil? || max_duration.nil? || max_duration.zero?
+
+        width_percentage = [(duration.to_f / max_duration * 100), 100].min
+        content_tag(:div, "", class: "timeline-duration-bar", style: "width: #{format('%.1f', width_percentage)}%")
+      end
+
+      def format_timeline_duration(duration_ms)
+        return "N/A" if duration_ms.nil?
+
+        if duration_ms < 1
+          "< 1ms"
+        elsif duration_ms < 1000
+          format("%.1fms", duration_ms)
+        else
+          format("%.1fs", duration_ms / 1000.0)
+        end
+      end
+
+      def timeline_event_icon(entry)
+        case entry.level
+        when "error", "fatal"
+          "⚠️"
+        when "warn"
+          "⚡"
+        when "info"
+          "ℹ️"
+        when "debug"
+          "🔍"
+        else
+          "•"
+        end
+      end
+    end
+  end
+end

data/app/services/solid_log/ui/live_tail_broadcaster.rb

@@ -0,0 +1,81 @@
+module SolidLog
+  module UI
+    class LiveTailBroadcaster
+      # Broadcast new entries to live tail subscribers
+      # Called after entries are inserted by the parser
+      def self.broadcast_entries(entry_ids)
+        return unless SolidLog::UI.configuration.websocket_enabled
+        return unless defined?(ActionCable)
+        return if entry_ids.empty?
+
+        entries = SolidLog::Entry.where(id: entry_ids).order(:id)
+
+        # Get all unique filter combinations currently subscribed
+        # We'll broadcast each entry to all matching filter streams
+        active_filters = get_active_filter_streams
+
+        entries.each do |entry|
+          # Render the entry HTML once
+          html = ApplicationController.render(
+            partial: "solid_log/ui/streams/log_row",
+            locals: { entry: entry, query: nil }
+          )
+
+          # Broadcast to each filter stream where this entry matches
+          active_filters.each do |filter_key, filters|
+            if entry_matches_filters?(entry, filters)
+              stream_name = "solid_log_stream_#{filter_key}"
+              ActionCable.server.broadcast(
+                stream_name,
+                {
+                  html: html,
+                  entry_id: entry.id
+                }
+              )
+            end
+          end
+        end
+      end
+
+      private
+
+      def self.get_active_filter_streams
+        # Get all currently active filter combinations from Rails.cache
+        # This works across all processes and survives restarts (within cache TTL)
+        if defined?(SolidLog::UI::LogStreamChannel)
+          SolidLog::UI::LogStreamChannel.active_filter_combinations
+        else
+          # Fallback: just check empty filters
+          { generate_filter_key({}) => {} }
+        end
+      end
+
+      def self.entry_matches_filters?(entry, filters)
+        return true if filters.empty?
+
+        # Check each filter
+        filters.each do |key, values|
+          values = Array(values).reject(&:blank?)
+          next if values.empty?
+
+          entry_value = entry.public_send(key) rescue nil
+
+          # If entry doesn't have this field and filter requires it, no match
+          return false if entry_value.nil?
+
+          # Check if entry value matches any of the filter values
+          unless values.map(&:to_s).include?(entry_value.to_s)
+            return false
+          end
+        end
+
+        true
+      end
+
+      def self.generate_filter_key(filters)
+        normalized = filters.sort.to_h
+        Digest::MD5.hexdigest(normalized.to_json)
+      end
+    end
+  end
+end