rails-pretty-logger 0.2.9 → 0.3.0

data/app/assets/stylesheets/rails/pretty/logger/list.css

@@ -1,94 +1 @@
-.clear_logs {
-  background-color: #F62817 !important ;
-  color: white;
-  padding: 15px 32px;
-  text-align: center;
-  text-decoration: none;
-  display: inline-block;
-  font-size: 14px;
-}
-
-
-
-.message{
-	text-align: center;
-}
-
-
-.list {
-	font-family:sans-serif;
-}
-td {
-	padding:10px;
-	border:solid 1px #eee;
-}
-
-input {
-	border:solid 1px #ccc;
-	border-radius: 5px;
-	padding:7px 14px;
-	margin-bottom:10px
-}
-input:focus {
-	outline:none;
-	border-color:#aaa;
-}
-.sort {
-	padding:8px 30px;
-	border-radius: 6px;
-	border:none;
-	display:inline-block;
-	color:#fff;
-	text-decoration: none;
-	background-color: #28a8e0;
-	height:30px;
-}
-.sort:hover {
-	text-decoration: none;
-	background-color:#1b8aba;
-}
-.sort:focus {
-	outline:none;
-}
-.sort:after {
-	display:inline-block;
-	width: 0;
-	height: 0;
-	border-left: 5px solid transparent;
-	border-right: 5px solid transparent;
-	border-bottom: 5px solid transparent;
-	content:"";
-	position: relative;
-	top:-10px;
-	right:-5px;
-}
-.sort.asc:after {
-	width: 0;
-	height: 0;
-	border-left: 5px solid transparent;
-	border-right: 5px solid transparent;
-	border-top: 5px solid #fff;
-	content:"";
-	position: relative;
-	top:4px;
-	right:-5px;
-}
-.sort.desc:after {
-	width: 0;
-	height: 0;
-	border-left: 5px solid transparent;
-	border-right: 5px solid transparent;
-	border-bottom: 5px solid #fff;
-	content:"";
-	position: relative;
-	top:-4px;
-	right:-5px;
-}
-
-.pagination li {
-	display: inline-table;
-}
-
-ul {
-  list-style-type: none;
-}
+/* Compatibility logical asset for applications that reference rails/pretty/logger/list.css. */

data/app/controllers/rails/pretty/logger/application_controller.rb

@@ -2,7 +2,38 @@ module Rails
   module Pretty
     module Logger
       class ApplicationController < ActionController::Base
+        helper Rails::Pretty::Logger::ApplicationHelper
+        helper Rails::Pretty::Logger::DashboardsHelper
+
         protect_from_forgery with: :exception
+
+        before_action :authenticate_rails_pretty_logger
+
+        rescue_from Rails::Pretty::Logger::PrettyLogger::InvalidLogFile, with: :invalid_log_file
+        rescue_from Rails::Pretty::Logger::PrettyLogger::FileTooLarge, with: :log_file_too_large
+
+        private
+
+        def authenticate_rails_pretty_logger
+          auth_hook = Rails::Pretty::Logger.configuration.authenticate_with || legacy_authenticate_with
+          instance_exec(&auth_hook) if auth_hook.respond_to?(:call)
+        end
+
+        def ensure_writable_rails_pretty_logger
+          head :forbidden if Rails::Pretty::Logger.configuration.read_only?
+        end
+
+        def invalid_log_file
+          render plain: "Invalid log file", status: :bad_request
+        end
+
+        def log_file_too_large
+          render plain: "Log file is too large", status: 413
+        end
+
+        def legacy_authenticate_with
+          Rails.application.config.x.rails_pretty_logger.authenticate_with
+        end
       end
     end
   end

data/app/controllers/rails/pretty/logger/dashboards_controller.rb

@@ -1,11 +1,12 @@
 require_dependency "rails/pretty/logger/application_controller"
 
-module Rails::Pretty::Logger
+  module Rails::Pretty::Logger
   class DashboardsController < ApplicationController
     before_action :set_logger, except: [:index]
+    before_action :ensure_writable_rails_pretty_logger, only: [:clear_logs]
 
     def logs
-      @log_data = @log.log_data
+      @log_data = tail_mode? ? @log.tail_log_data : @log.log_data
     end
 
     def index
@@ -14,17 +15,21 @@ module Rails::Pretty::Logger
 
     def clear_logs
       @log.clear_logs
-      redirect_to logs_dashboards_path({log_file: params[:log_file]})
+      redirect_to logs_dashboards_path({log_file: @log.log_file})
     end
 
     private
 
     def dashboard_params
-      params.permit( :log_file, :utf8, :_method, :authenticity_token, :commit, :page, date_range: [:end, :start, :divider])
+      params.permit( :log_file, :mode, :group, :query, :severity, :utf8, :_method, :authenticity_token, :commit, :page, date_range: [:end, :start, :divider])
     end
 
     def set_logger
       @log = PrettyLogger.new(dashboard_params)
     end
+
+    def tail_mode?
+      dashboard_params[:mode] == "tail"
+    end
   end
 end

data/app/controllers/rails/pretty/logger/hourly_logs_controller.rb

@@ -2,29 +2,61 @@ require_dependency "rails/pretty/logger/application_controller"
 
 module Rails::Pretty::Logger
   class HourlyLogsController < ApplicationController
+    PER_PAGE = 12
+
     before_action :set_logger, except: [:index]
+    before_action :ensure_writable_rails_pretty_logger, only: [:clear_logs]
 
     def logs
-      @log_data = @log.log_data
+      @log_data = tail_mode? ? @log.tail_log_data : @log.log_data
     end
 
     def index
-      @log_file_list = PrettyLogger.get_hourly_log_file_list.select{ |_,file| file[:file_size] > 0 }
+      logs = PrettyLogger.get_hourly_log_file_list.values.select { |file| file[:file_size] > 0 }
+      @hourly_logs_present = logs.any?
+      logs = filter_logs(logs)
+      logs = sort_logs(logs)
+
+      @page = [index_params[:page].to_i, 1].max
+      @total_pages = (logs.count.to_f / PER_PAGE).ceil
+      @total_pages = 1 if @total_pages.zero?
+      @page = @total_pages if @page > @total_pages
+      @log_file_list = logs.slice((@page - 1) * PER_PAGE, PER_PAGE) || []
     end
 
     def clear_logs
       @log.clear_logs
-      redirect_to hourly_logs_path({log_file: params[:log_file]})
+      redirect_to hourly_logs_path({log_file: @log.log_file})
     end
 
     private
 
+    def index_params
+      params.permit(:search, :sort, :page)
+    end
+
+    def filter_logs(logs)
+      return logs if index_params[:search].blank?
+
+      query = index_params[:search].downcase
+      logs.select { |file| file[:file_name].downcase.include?(query) }
+    end
+
+    def sort_logs(logs)
+      logs = logs.sort_by { |file| file[:file_name] }
+      index_params[:sort] == "desc" ? logs.reverse : logs
+    end
+
     def hourly_params
-      params.permit( :log_file, :utf8, :_method, :authenticity_token, :commit, :page, date_range: [:end, :start, :divider])
+      params.permit( :log_file, :mode, :group, :query, :severity, :utf8, :_method, :authenticity_token, :commit, :page, date_range: [:end, :start, :divider])
     end
 
     def set_logger
       @log = PrettyLogger.new(hourly_params)
     end
+
+    def tail_mode?
+      hourly_params[:mode] == "tail"
+    end
   end
 end

data/app/helpers/rails/pretty/logger/application_helper.rb

@@ -9,5 +9,37 @@ module Rails::Pretty::Logger
       index = name.split("/log/").last.capitalize
     end
 
+    def rails_pretty_logger_read_only?
+      Rails::Pretty::Logger.configuration.read_only?
+    end
+
+    def rails_pretty_logger_tail_mode?
+      params[:mode] == "tail"
+    end
+
+    def rails_pretty_logger_request_grouping?
+      params[:group] == "request"
+    end
+
+    def rails_pretty_logger_severity_options
+      [["All levels", ""]] + Rails::Pretty::Logger::PrettyLogger::SEVERITIES.map { |severity| [severity, severity] }
+    end
+
+    def rails_pretty_logger_log_base_params(include_group: true)
+      log_params = { log_file: params[:log_file] }
+      log_params[:mode] = params[:mode] if params[:mode].present?
+      log_params[:group] = params[:group] if include_group && params[:group].present?
+      log_params
+    end
+
+    def rails_pretty_logger_log_filter_params(include_mode: true, include_group: true)
+      log_params = { log_file: params[:log_file] }
+      log_params[:mode] = params[:mode] if include_mode && params[:mode].present?
+      log_params[:group] = params[:group] if include_group && params[:group].present?
+      log_params[:query] = params[:query] if params[:query].present?
+      log_params[:severity] = params[:severity] if params[:severity].present?
+      log_params
+    end
+
   end
 end

data/app/helpers/rails/pretty/logger/dashboards_helper.rb

@@ -1,11 +1,20 @@
 module Rails::Pretty::Logger
   module DashboardsHelper
+    STRUCTURED_LOG_PRIMARY_KEYS = %w[@timestamp timestamp time datetime created_at severity level log_level message msg].freeze
+
     def check_highlight(line)
-      return "<div class='highlight'>#{line.remove('[HIGHLIGHT]')}</div>".html_safe if line.include?("[HIGHLIGHT]")
-      if line.include?("Parameters:")
-        parse_parameters(line)
+      rails_pretty_logger_log_entry(line)
+    end
+
+    def rails_pretty_logger_log_entry(entry)
+      return rails_pretty_logger_request_group(entry) if entry.is_a?(Hash)
+      return rails_pretty_logger_structured_log(entry) if rails_pretty_logger_structured_payload(entry)
+      return tag.div(entry.remove("[HIGHLIGHT]"), class: "log-line highlight") if entry.include?("[HIGHLIGHT]")
+
+      if entry.include?("Parameters:")
+        tag.div(parse_parameters(entry), class: "log-line log-line--parameters")
       else
-        line
+        tag.div(entry, class: "log-line")
       end
     end
 
@@ -35,21 +44,112 @@ module Rails::Pretty::Logger
       "active" if params[:page].to_i == index
     end
 
-    def check_rails_version
-      Rails::VERSION::STRING[0..2].to_f < 5.2
+    def parse_parameters(line)
+      parameters = line[line.index("Parameters:") + "Parameters:".length..]
+      hash = JSON.parse(parameters.gsub("=>", ":"))
+      parts = [tag.strong("Parameters:"), tag.br]
+      hash.each do |key, value|
+        parts << tag.strong("#{key}: ")
+        parts << value.to_s
+        parts << ", "
+      end
+      safe_join(parts)
+    rescue JSON::ParserError, TypeError
+      line
     end
 
-    def parse_parameters(line)
-      parameters = line[line.index("Parameters:") + 12 ..line.length]
-      hash = JSON.parse parameters.gsub('=>', ':') rescue nil
-      if hash.nil?
-        line
-      else
-        h = hash.reduce("<strong> Parameters: </strong> <br/> ") {|memo, (k,v)| memo += "<strong> #{k}: </strong> #{v}, "} rescue nil
-        h.html_safe rescue nil
+    def rails_pretty_logger_request_group(group)
+      tag.details(class: rails_pretty_logger_request_group_classes(group), open: true) do
+        safe_join([
+          tag.summary(rails_pretty_logger_request_summary(group), class: "log-request__summary"),
+          tag.pre(group.fetch(:lines).join, class: "log-request__body")
+        ])
+      end
+    end
+
+    def rails_pretty_logger_request_summary(group)
+      return t("rails_pretty_logger.logs.ungrouped_lines") unless group[:type] == :request
+
+      parts = [
+        tag.span(group[:method], class: "log-request__method"),
+        tag.span(group[:path], class: "log-request__path")
+      ]
+      parts << tag.span(group[:status], class: "log-request__status") if group[:status].present?
+      parts << tag.span(group[:duration], class: "log-request__duration") if group[:duration].present?
+
+      safe_join(parts, " ")
+    end
+
+    def rails_pretty_logger_request_group_classes(group)
+      classes = ["log-request"]
+      classes << "log-request--error" if group[:status].to_i >= 500
+      classes.join(" ")
+    end
+
+    def rails_pretty_logger_structured_log(line)
+      payload = rails_pretty_logger_structured_payload(line)
+      severity = rails_pretty_logger_structured_value(payload, *Rails::Pretty::Logger::PrettyLogger::STRUCTURED_SEVERITY_KEYS)
+      severity ||= rails_pretty_logger_structured_nested_log_level(payload)
+      timestamp = rails_pretty_logger_structured_value(payload, *Rails::Pretty::Logger::PrettyLogger::STRUCTURED_TIMESTAMP_KEYS)
+      message = payload["message"] || payload["msg"] || line
+
+      tag.div(class: rails_pretty_logger_structured_log_classes(severity)) do
+        safe_join([
+          tag.div(class: "structured-log__header") do
+            rails_pretty_logger_structured_header(severity, timestamp, message)
+          end,
+          rails_pretty_logger_structured_metadata(payload)
+        ].compact)
       end
     end
 
+    def rails_pretty_logger_structured_header(severity, timestamp, message)
+      parts = []
+      parts << tag.span(severity, class: "structured-log__severity") if severity.present?
+      parts << tag.span(timestamp, class: "structured-log__timestamp") if timestamp.present?
+      parts << tag.strong(message, class: "structured-log__message")
+
+      safe_join(parts)
+    end
+
+    def rails_pretty_logger_structured_metadata(payload)
+      metadata = payload.reject { |key, _value| STRUCTURED_LOG_PRIMARY_KEYS.include?(key.to_s) }
+      return if metadata.blank?
+
+      tag.dl(class: "structured-log__metadata") do
+        safe_join(metadata.flat_map do |key, value|
+          [
+            tag.dt(key),
+            tag.dd(value.is_a?(Hash) || value.is_a?(Array) ? JSON.generate(value) : value.to_s)
+          ]
+        end)
+      end
+    end
+
+    def rails_pretty_logger_structured_log_classes(severity)
+      classes = ["structured-log"]
+      classes << "structured-log--#{severity.to_s.downcase}" if severity.present?
+      classes.join(" ")
+    end
+
+    def rails_pretty_logger_structured_payload(line)
+      Rails::Pretty::Logger::PrettyLogger.structured_log_payload(line)
+    end
+
+    def rails_pretty_logger_structured_value(payload, *keys)
+      keys.each do |key|
+        return payload[key].to_s if payload[key].present?
+      end
+
+      nil
+    end
+
+    def rails_pretty_logger_structured_nested_log_level(payload)
+      nested_log = payload["log"]
+      return unless nested_log.respond_to?(:[])
+
+      nested_log["level"].to_s.upcase.presence
+    end
 
   end
 end

data/app/views/layouts/rails/pretty/logger/application.html.erb

@@ -2,15 +2,16 @@
 <html>
 <head>
   <title>Rails pretty logger</title>
-  <% if check_rails_version %>
-    <%= csrf_meta_tags %>
-  <% else %>
-    <%= csrf_meta_tags %>
-    <%= csp_meta_tag %>
-  <% end %>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
 
-  <%= stylesheet_link_tag    "rails/pretty/logger/application", media: "all" %>
-  <%= javascript_include_tag "rails/pretty/logger/application" %>
+  <%= stylesheet_link_tag(
+    "rails/pretty/logger/application",
+    "rails/pretty/logger/dashboards",
+    "rails/pretty/logger/list",
+    media: "all"
+  ) %>
+  <%= javascript_include_tag "rails/pretty/logger/application", defer: true %>
 </head>
 <body>
 

data/app/views/partials/_error_pagination.html.erb

@@ -1,21 +1,23 @@
 <% if log_data.fetch(:error).present? %>
-<p>
+<p class="form-error">
   <%= log_data.fetch(:error) %>
 </p>
 <% end %>
 
-<% if log_data.fetch(:error).blank? %>
+<% if log_data.fetch(:error).blank? && log_data.fetch(:logs_count).positive? %>
+  <nav class="pagination" aria-label="<%= t("rails_pretty_logger.navigation.pagination") %>">
   <% log_data.fetch(:logs_count).times do |index| %>
     <%= link_to(
-        index + 1,
-        send(locals[:path],
-          log_file: params.fetch(:log_file),
+      index + 1,
+      send(
+        locals[:path],
+        rails_pretty_logger_log_filter_params(include_mode: false).merge(
           page: index,
           date_range: { start: log.start_date, end: log.end_date, divider: set_divider(params) }
-        ),
-        html_options = {class: "#{is_page_active(index, params)}"}
-
-      ) %>
+        )
+      ),
+      html_options = {class: "#{is_page_active(index, params)}"}
+    ) %>
   <% end %>
+  </nav>
 <% end %>
-<hr>

data/app/views/partials/_log_entries.html.erb

@@ -0,0 +1,5 @@
+<div class="log-entries">
+  <% log_data.fetch(:paginated_logs).each do |entry| %>
+    <%= rails_pretty_logger_log_entry(entry) %>
+  <% end %>
+</div>

data/app/views/partials/_log_filters.html.erb

@@ -0,0 +1,14 @@
+<%= form_with url: send(path), method: :get, scope: nil, class: "log_filters" do |form| %>
+  <%= form.hidden_field :log_file, value: params[:log_file] %>
+  <%= form.hidden_field :mode, value: params[:mode] if rails_pretty_logger_tail_mode? %>
+  <%= form.hidden_field :group, value: params[:group] if rails_pretty_logger_request_grouping? %>
+
+  <%= form.label :query, t("rails_pretty_logger.filters.search") %>
+  <%= form.search_field :query, value: params[:query], placeholder: t("rails_pretty_logger.filters.search_log_content") %>
+
+  <%= form.label :severity, t("rails_pretty_logger.filters.severity") %>
+  <%= form.select :severity, rails_pretty_logger_severity_options, selected: params[:severity] %>
+
+  <%= form.submit t("rails_pretty_logger.filters.filter") %>
+  <%= link_to(t("rails_pretty_logger.filters.clear_filters"), send(path, rails_pretty_logger_log_base_params)) %>
+<% end %>

data/app/views/partials/_pretyyloggernavbar.html.erb

@@ -1,14 +1,19 @@
-
 <div class="logger_navbar">
-  <p>
-    <%= link_to(path_name, hourly_logs_path, html_options = {class: "dashboard_button"}) %>
-  </p>
-  Log Files:
+  <div class="logger_navbar__heading">
+    <h1><%= t("rails_pretty_logger.navigation.main_logs") %></h1>
+  </div>
+
+  <nav class="logger_navbar__actions">
+    <%= link_to(path_name, hourly_logs_path, class: "dashboard_button") %>
+  </nav>
+</div>
+
+<nav class="log-file-strip" aria-label="<%= t("rails_pretty_logger.navigation.log_files") %>">
+  <span class="log-file-strip__label"><%= t("rails_pretty_logger.navigation.log_files") %></span>
   <% Rails::Pretty::Logger::PrettyLogger.get_log_file_list.each do |key, value| %>
-  <%= link_to(trim_name(value[:file_name]),
+    <%= link_to(trim_name(value[:file_name]),
       logs_dashboards_path(log_file: value[:file_name], date_range: { start: time_now, end: time_now }),
       html_options = {class: "#{is_file_active(value[:file_name], params)}",
-      data: { confirm: "Log file size is #{ value[:file_size] } MB. Are you sure to open this file? " }}) %>
+      data: { confirm: t("rails_pretty_logger.confirmations.open_file", size: value[:file_size]) }}) %>
   <% end %>
-</div>
-<hr>
+</nav>

data/app/views/rails/pretty/logger/dashboards/index.html.erb

@@ -1,31 +1,48 @@
 <% if @log_file_list.count == 0 %>
-  <div>
-    <h1 class="message">There is no log file to show</h1>
+  <div class="empty-state">
+    <h1 class="message"><%= t("rails_pretty_logger.states.no_logs") %></h1>
   </div>
 
 <%  elsif is_stdout?%>
-  <div>
-    <h1 class="message">  "RAILS_LOG_TO_STDOUT" is present. no logs kept, remove it for logging </h1>
+  <div class="empty-state">
+    <h1 class="message"><%= t("rails_pretty_logger.states.stdout_logging") %></h1>
   </div>
 
 <% else %>
   <div class="logger_navbar">
-    <p>
-      <%= link_to('Hourly logs', hourly_logs_path, html_options = {class: "dashboard_button"}) %>
-    </p>
-      Log Files:
-      <% @log_file_list .each do |key, value| %>
-        <%= link_to(trim_name(value.fetch(:file_name)),
-        logs_dashboards_path(log_file: value.fetch(:file_name), date_range: { start: time_now, end: time_now }),
-        html_options = {class: "dashboard_button",
-        data: { confirm: "Log file size is #{ value[:file_size] } MB. Are you sure to open this file? " }}) %>
-
-        <%= link_to("x",
-        clear_logs_dashboards_path(log_file: value.fetch(:file_name)),
-        html_options = {class: "clear_logs",
-        method: :post,
-        data: { confirm: "Are you sure to clear all logs from #{value.fetch(:file_name).capitalize}? " }}) %>
-      <% end %>
+    <div class="logger_navbar__heading">
+      <h1><%= t("rails_pretty_logger.navigation.main_logs") %></h1>
+    </div>
 
+    <nav class="logger_navbar__actions">
+      <%= link_to(t("rails_pretty_logger.navigation.hourly_logs"), hourly_logs_path, class: "dashboard_button") %>
+    </nav>
   </div>
+
+  <section class="log-file-list" aria-label="<%= t("rails_pretty_logger.navigation.log_files") %>">
+    <div class="log-file-list__header">
+      <h2><%= t("rails_pretty_logger.navigation.log_files") %></h2>
+    </div>
+
+    <% @log_file_list.each do |_key, value| %>
+      <div class="log-file-row">
+        <div class="log-file-row__main">
+          <%= link_to(trim_name(value.fetch(:file_name)),
+            logs_dashboards_path(log_file: value.fetch(:file_name), date_range: { start: time_now, end: time_now }),
+            html_options = {class: "log-file-row__name",
+            data: { confirm: t("rails_pretty_logger.confirmations.open_file", size: value[:file_size]) }}) %>
+          <span class="log-file-row__meta"><%= t("rails_pretty_logger.logs.file_size", size: value[:file_size]) %></span>
+        </div>
+
+        <% unless rails_pretty_logger_read_only? %>
+          <%= button_to(t("rails_pretty_logger.actions.clear"),
+            clear_logs_dashboards_path(log_file: value.fetch(:file_name)),
+            method: :post,
+            class: "clear_logs",
+            form: { class: "clear_logs_form",
+            data: { turbo_confirm: t("rails_pretty_logger.confirmations.clear_file", file: value.fetch(:file_name).capitalize) }}) %>
+        <% end %>
+      </div>
+    <% end %>
+  </section>
 <% end %>