onlylogs 0.11.0 → 0.13.0

data/app/javascript/onlylogs/controllers/text_selection_controller.js

@@ -6,12 +6,16 @@ export default class TextSelectionController extends Controller {
   connect() {
     this.boundHandleTextSelection = this.handleTextSelection.bind(this)
     this.boundHandleDocumentClick = this.handleDocumentClick.bind(this)
+    this.boundHandleDocumentMouseDown = this.handleDocumentMouseDown.bind(this)
     this.boundHandleSelectionChange = this.handleSelectionChange.bind(this)
     this.boundHandleMouseDown = this.handleMouseDown.bind(this)
+    this.boundPlaceButton = this.placeButton.bind(this)
 
     // Only listen for text selection on the log lines, not the toolbar
     this.logLinesTarget.addEventListener('mousedown', this.boundHandleMouseDown)
     this.logLinesTarget.addEventListener('mouseup', this.boundHandleTextSelection)
+    this.logLinesTarget.addEventListener('scroll', this.boundPlaceButton)
+    document.addEventListener('mousedown', this.boundHandleDocumentMouseDown)
     document.addEventListener('click', this.boundHandleDocumentClick)
     document.addEventListener('selectionchange', this.boundHandleSelectionChange)
   }
@@ -19,43 +23,80 @@ export default class TextSelectionController extends Controller {
   disconnect() {
     this.logLinesTarget.removeEventListener('mousedown', this.boundHandleMouseDown)
     this.logLinesTarget.removeEventListener('mouseup', this.boundHandleTextSelection)
+    this.logLinesTarget.removeEventListener('scroll', this.boundPlaceButton)
+    document.removeEventListener('mousedown', this.boundHandleDocumentMouseDown)
     document.removeEventListener('click', this.boundHandleDocumentClick)
     document.removeEventListener('selectionchange', this.boundHandleSelectionChange)
   }
 
-  handleMouseDown() {
+  handleMouseDown(event) {
+    if (this.#onScrollbar(event)) return
+
     this.dispatch("start")
   }
 
+  handleDocumentMouseDown(event) {
+    if (this.buttonTarget.contains(event.target) || this.#onScrollbar(event)) return
+
+    this.saved = null
+  }
+
   handleTextSelection(event) {
     const selection = window.getSelection()
     const selectedText = selection.toString().trim()
-    
+
     // Check if there's actually a text selection
     if (selectedText.length > 0 && selection.rangeCount > 0) {
-      this.showButton(event, selectedText)
+      this.showButton(event.clientX, event.clientY, selectedText)
     } else {
       this.hideButton()
     }
   }
 
-  showButton(event, selectedText) {
+  // Bound to log-cursor:select, a selection made with the keyboard.
+  showForSelection() {
+    const selection = window.getSelection()
+    const selectedText = selection.toString().trim()
+    if (selectedText.length === 0 || selection.rangeCount === 0) return
+
+    this.saved = null
+    const rect = selection.getRangeAt(0).getBoundingClientRect()
+    this.showButton(rect.left + 40, rect.bottom, selectedText)
+  }
+
+  showButton(clientX, clientY, selectedText) {
     if (!this.buttonTarget) {
       return
     }
-    
+
     const containerRect = this.element.getBoundingClientRect()
-    
+
     // Position button below mouse cursor
-    const left = event.clientX - containerRect.left - 40 // Roughly center the button
-    const top = event.clientY - containerRect.top + 10
-    
-    this.buttonTarget.style.left = Math.max(0, left) + 'px'
-    this.buttonTarget.style.top = Math.max(0, top) + 'px'
-    this.buttonTarget.style.display = 'block'
-    
+    this.buttonPosition = {
+      left: clientX - containerRect.left - 40, // Roughly center the button
+      top: clientY - containerRect.top + 10,
+      scrollLeft: this.logLinesTarget.scrollLeft,
+      scrollTop: this.logLinesTarget.scrollTop
+    }
+
     // Store selected text for search
     this.selectedText = selectedText
+    this.placeButton()
+  }
+
+  placeButton() {
+    if (!this.buttonPosition || !this.selectedText) return
+
+    const lines = this.logLinesTarget
+    const left = this.buttonPosition.left - (lines.scrollLeft - this.buttonPosition.scrollLeft)
+    const top = this.buttonPosition.top - (lines.scrollTop - this.buttonPosition.scrollTop)
+
+    const linesTop = lines.getBoundingClientRect().top - this.element.getBoundingClientRect().top
+    const visible = top >= linesTop && top <= linesTop + lines.clientHeight - this.buttonTarget.offsetHeight
+
+    this.buttonTarget.style.left = Math.max(0, left) + 'px'
+    this.buttonTarget.style.top = Math.max(0, top) + 'px'
+    this.buttonTarget.style.display = visible ? 'block' : 'none'
   }
 
   hideButton() {
@@ -63,6 +104,35 @@ export default class TextSelectionController extends Controller {
     this.selectedText = null
   }
 
+  saveSelection({ detail: { start } }) {
+    const selection = window.getSelection()
+    if (!this.#selectionInLines(selection)) return
+
+    const anchor = this.#positionOf(selection.anchorNode, selection.anchorOffset, start)
+    const focus = this.#positionOf(selection.focusNode, selection.focusOffset, start)
+    if (anchor && focus) this.saved = { anchor, focus }
+  }
+
+  restoreSelection({ detail: { start } }) {
+    if (!this.saved) return
+
+    const selection = window.getSelection()
+    if (this.#selectionInLines(selection)) return
+
+    const anchor = this.#pointIn(this.saved.anchor, start)
+    const focus = this.#pointIn(this.saved.focus, start)
+    if (!anchor || !focus) return
+
+    selection.setBaseAndExtent(anchor.node, anchor.offset, focus.node, focus.offset)
+    this.selectedText = selection.toString().trim()
+    this.placeButton()
+  }
+
+  forgetSelection() {
+    this.saved = null
+    this.hideButton()
+  }
+
   handleDocumentClick(event) {
     // Only hide if clicking outside the button and outside the log lines container
     if (!this.buttonTarget.contains(event.target) && !this.logLinesTarget.contains(event.target)) {
@@ -74,7 +144,7 @@ export default class TextSelectionController extends Controller {
     // Check if the current selection is still valid
     const selection = window.getSelection()
     const selectedText = selection.toString().trim()
-    
+
     // If no text is selected, hide the button
     if (selectedText.length === 0 || selection.rangeCount === 0) {
       this.hideButton()
@@ -87,12 +157,63 @@ export default class TextSelectionController extends Controller {
         this.regexpModeTarget.checked = false
         this.regexpModeTarget.dispatchEvent(new Event('change', { bubbles: true }))
       }
-      
+
       this.filterInputTarget.value = this.selectedText
       this.filterInputTarget.dispatchEvent(new Event('input', { bubbles: true }))
       this.dispatch("search")
       this.hideButton()
+      this.saved = null
       window.getSelection().removeAllRanges()
     }
   }
+
+  #onScrollbar(event) {
+    const lines = this.logLinesTarget
+    if (event.target !== lines) return false
+
+    const rect = lines.getBoundingClientRect()
+    return event.clientX - rect.left >= lines.clientWidth || event.clientY - rect.top >= lines.clientHeight
+  }
+
+  #selectionInLines(selection) {
+    return !selection.isCollapsed && this.#content.contains(selection.anchorNode) && this.#content.contains(selection.focusNode)
+  }
+
+  #positionOf(node, offset, start) {
+    const row = this.#rowFor(node)
+    if (!row) return null
+
+    const range = document.createRange()
+    range.setStart(row, 0)
+    range.setEnd(node, offset)
+    return { row: start + this.#renderedRows().indexOf(row), offset: range.toString().length }
+  }
+
+  #pointIn(position, start) {
+    const row = this.#renderedRows()[position.row - start]
+    if (!row) return null
+
+    const walker = document.createTreeWalker(row, NodeFilter.SHOW_TEXT)
+    let remaining = position.offset
+    let last = null
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      if (remaining <= node.length) return { node, offset: remaining }
+      remaining -= node.length
+      last = node
+    }
+    return last ? { node: last, offset: last.length } : { node: row, offset: 0 }
+  }
+
+  #rowFor(node) {
+    while (node && node.parentNode !== this.#content) node = node.parentNode
+    return node && !node.classList.contains("clusterize-extra-row") ? node : null
+  }
+
+  #renderedRows() {
+    return [...this.#content.children].filter(row => !row.classList.contains("clusterize-extra-row"))
+  }
+
+  get #content() {
+    return this.logLinesTarget.querySelector(".clusterize-content")
+  }
 }

data/app/models/onlylogs/file.rb

@@ -1,6 +1,4 @@
 module Onlylogs
-  class Error < StandardError; end
-
   class File
     attr_reader :path, :last_position
 
@@ -11,6 +9,16 @@ module Onlylogs
       @inode = ::File.stat(path).ino
     end
 
+    QUERIES_DATABASE = "queries.sqlite3"
+
+    # The saved queries of this file's directory, shared by all log files in it, newest first.
+    def queries = QueriesRecord.bound_to(queries_database_path) { Query.newest_first }
+
+    # Connects Query to the database of this file's directory.
+    def with_database(create: true, &) = QueriesRecord.with_database(queries_database_path, create: create, &)
+
+    def queries_database_path = ::File.join(::File.dirname(path), Onlylogs.configuration.database_dir, QUERIES_DATABASE)
+
     def go_to_position(position)
       return if position < 0
 
@@ -68,10 +76,11 @@ module Onlylogs
 
     # +timeout+ is in seconds and defaults to nil, meaning unbounded. See
     # Grep.grep.
-    def grep(filter, regexp_mode: false, start_position: 0, end_position: nil,
+    def grep(filter, regexp_mode: false, case_sensitive: true, start_position: 0, end_position: nil,
       max_matches: Onlylogs.max_line_matches, timeout: nil, &block)
-      Grep.grep(filter, path, regexp_mode: regexp_mode, start_position: start_position,
-        end_position: end_position, max_matches: max_matches, timeout: timeout) do |content|
+      Grep.grep(filter, path, regexp_mode: regexp_mode, case_sensitive: case_sensitive,
+        start_position: start_position, end_position: end_position, max_matches: max_matches,
+        timeout: timeout) do |content|
         yield content
       end
     end

data/app/models/onlylogs/grep.rb

@@ -12,36 +12,46 @@ module Onlylogs
     # is deliberately not a number, because only the caller knows how long it
     # can afford to hold the thread it runs on. Anything serving a request
     # should pass one.
+    # +context+ asks for that many lines before and after each match, yielded with
+    # <tt>context: true</tt>. It needs ripgrep: plain grep is run without byte
+    # offsets, so its context lines could not be told apart from matches, and
+    # +context+ is ignored there. Context never reaches outside the byte window.
     def self.grep(pattern, file_path, start_position: 0, end_position: nil, regexp_mode: false,
-      max_matches: Onlylogs.max_line_matches, timeout: nil, &block)
+      case_sensitive: true, max_matches: Onlylogs.max_line_matches, context: 0, timeout: nil, &block)
+      context = 0 unless Onlylogs.ripgrep_enabled?
       command_args = search_command(pattern, file_path, start_position: start_position,
-        end_position: end_position, regexp_mode: regexp_mode, max_matches: max_matches)
+        end_position: end_position, regexp_mode: regexp_mode, case_sensitive: case_sensitive,
+        max_matches: max_matches, context: context)
 
       results = []
 
-      # Set up parsing logic based on whether ripgrep includes byte offsets
+      # ripgrep prints "offset:line" for a match and "offset-line" for context
       parse_line = if Onlylogs.ripgrep_enabled?
         ->(line) {
-          parts = line.split(":", 2)
-          [parts[0].to_i + start_position, parts[1] || ""]
+          offset, separator, content = line.partition(/[:-]/)
+          [offset.to_i + start_position, content, separator == "-"]
         }
       else
-        ->(line) { [nil, line] }
+        ->(line) { [nil, line, false] }
       end
 
       matches = 0
 
       ActiveSupport::Notifications.instrument("search.onlylogs", file_path: file_path,
-        query: pattern, regexp: regexp_mode, start_position: start_position,
+        query: pattern, regexp: regexp_mode, case_sensitive: case_sensitive, start_position: start_position,
         end_position: end_position, max_matches: max_matches) do |payload|
         each_output_line(command_args, timeout: timeout) do |line|
-          byte_offset, content = parse_line.call(line.chomp)
+          line = line.chomp
+          next if context.positive? && line == GROUP_SEPARATOR
+
+          byte_offset, content, context_line = parse_line.call(line)
 
           # Use String.new to create a copy and prevent memory retention from IO buffers
           content = String.new(content, encoding: Encoding::UTF_8).scrub
 
           result = {byte_offset: byte_offset, content: content}
-          matches += 1
+          result[:context] = true if context_line
+          matches += 1 unless context_line
 
           if block_given?
             yield result
@@ -61,14 +71,21 @@ module Onlylogs
       block_given? ? nil : results
     end
 
+    GROUP_SEPARATOR = "--"
+
+    # The scripts run under LC_ALL=C. ripgrep folds case over Unicode anyway,
+    # grep then folds ASCII only: "error" finds "ERROR" with both engines, but
+    # "über" finds "Über" with ripgrep only.
     def self.search_command(pattern, file_path, start_position: 0, end_position: nil, regexp_mode: false,
-      max_matches: Onlylogs.max_line_matches)
+      case_sensitive: true, max_matches: Onlylogs.max_line_matches, context: 0)
       script_name = Onlylogs.ripgrep_enabled? ? "super_ripgrep" : "super_grep"
       super_grep_path = ::File.expand_path("../../../bin/#{script_name}", __dir__)
 
       command_args = [super_grep_path]
       command_args += ["--max-matches", max_matches.to_s] if max_matches.present?
+      command_args += ["--context", context.to_s] if context.positive?
       command_args << "--regexp" if regexp_mode
+      command_args << "--case-insensitive" unless case_sensitive
 
       # Add byte range parameters if specified
       if start_position > 0 || end_position
@@ -170,14 +187,16 @@ module Onlylogs
 
     MATCH_TIMEOUT = 0.1 # seconds
 
-    def self.match_line?(line, string, regexp_mode: false)
+    # Folds case over Unicode, like ripgrep. See search_command for grep.
+    def self.match_line?(line, string, regexp_mode: false, case_sensitive: true)
       # Strip ANSI color codes from the line before matching
       stripped_line = line.gsub(/\e\[[0-9;]*m/, "")
       # Normalize multiple spaces to single spaces
       normalized_line = stripped_line.gsub(/\s+/, " ")
 
       pattern = regexp_mode ? string : Regexp.escape(string)
-      normalized_line.match?(Regexp.new(pattern, timeout: MATCH_TIMEOUT))
+      options = case_sensitive ? nil : Regexp::IGNORECASE
+      normalized_line.match?(Regexp.new(pattern, options, timeout: MATCH_TIMEOUT))
     rescue ::RegexpError
       false
     end

data/app/models/onlylogs/queries_record.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "sqlite_shards"
+
+module Onlylogs
+  # Saved queries live in a database kept in each log directory, shared by all log files in it:
+  # see File#with_database.
+  class QueriesRecord < ActiveRecord::Base
+    self.abstract_class = true
+    include SqliteShards
+
+    database_migrations(
+      ->(connection) {
+        connection.create_table(:queries, if_not_exists: true) do |t|
+          t.string :name, null: false
+          t.string :filter, null: false, default: ""
+          t.boolean :regexp_mode, null: false, default: false
+          t.timestamps
+
+          t.index "LOWER(name)", unique: true, name: "index_queries_on_lower_name"
+        end
+      },
+      ->(connection) {
+        unless connection.column_exists?(:queries, :case_insensitive)
+          connection.add_column(:queries, :case_insensitive, :boolean, null: false, default: false)
+        end
+      }
+    )
+  end
+end

data/app/models/onlylogs/query.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Onlylogs
+  class Query < QueriesRecord
+    self.table_name = "queries"
+
+    scope :newest_first, -> { order(created_at: :desc, id: :desc) }
+
+    normalizes :name, with: ->(name) { name.strip }
+
+    normalizes :filter, with: ->(filter) { filter.to_s }, apply_to_nil: true
+    normalizes :regexp_mode, with: ->(regexp_mode) { regexp_mode || false }, apply_to_nil: true
+    normalizes :case_insensitive, with: ->(case_insensitive) { case_insensitive || false }, apply_to_nil: true
+
+    validates :name, presence: true, length: {maximum: 255}, uniqueness: {case_sensitive: false}
+    validate :filter_must_be_a_valid_regexp
+
+    private
+
+    def filter_must_be_a_valid_regexp
+      return unless regexp_mode?
+      return if filter.blank?
+
+      Regexp.new(filter)
+    rescue RegexpError => e
+      errors.add(:filter, "is not a valid regexp: #{e.message}")
+    end
+  end
+end

data/app/views/onlylogs/logs/index.html.erb

@@ -42,7 +42,7 @@
 <div class="grid">
   <div class="grid-header">
     <% if @available_log_files.any? %>
-      <%= form_with url: root_path, method: :get, local: true, class: "log-file-dropdown", data: { controller: "auto-submit" } do %>
+      <%= form_with url: root_path, method: :get, local: true, class: "log-file-dropdown", data: { controller: "auto-submit", onlylogs_shortcut: "o" } do %>
         <select id="log_file_path" name="log_file_path" data-action="change->auto-submit#submit">
           <% @available_log_files.each do |file| %>
             <option value="<%= Onlylogs::SecureFilePath.encrypt(file) %>" <%= "selected" if file.to_s == @log_file_path.to_s %>>