onlylogs 0.1.2

data/app/models/onlylogs/ansi_color_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Onlylogs
+  class AnsiColorParser
+    ANSI_COLORS = {
+      "1" => "fw-bold",
+      "30" => "log-black",
+      "31" => "log-red",
+      "32" => "log-green",
+      "33" => "log-yellow",
+      "34" => "log-blue",
+      "35" => "log-magenta",
+      "36" => "log-cyan",
+      "37" => "log-white",
+      "39" => "", # Default foreground color (reset)
+      "0" => "" # Reset (no color)
+    }.freeze
+
+    # Pre-compiled regex for better performance
+    ANSI_REGEX = /\x1b\[(\d+)m/.freeze
+
+    # Pre-built HTML templates to avoid string interpolation (frozen for better performance)
+    HTML_TEMPLATES = {
+      "1" => '<span class="fw-bold">'.freeze,
+      "30" => '<span class="log-black">'.freeze,
+      "31" => '<span class="log-red">'.freeze,
+      "32" => '<span class="log-green">'.freeze,
+      "33" => '<span class="log-yellow">'.freeze,
+      "34" => '<span class="log-blue">'.freeze,
+      "35" => '<span class="log-magenta">'.freeze,
+      "36" => '<span class="log-cyan">'.freeze,
+      "37" => '<span class="log-white">'.freeze,
+      "39" => '<span class="">'.freeze,
+      "0" => "".freeze # Reset (no color)
+    }.freeze
+
+    # Pre-built closing span (frozen for better performance)
+    CLOSING_SPAN = '</span>'.freeze
+
+    def self.parse(string)
+      return string if string.blank?
+
+      # Early return if no ANSI codes present
+      return string unless string.include?("\x1b[")
+
+      result = string
+      stack = []
+
+      # Replace ANSI color codes with HTML spans
+      result = result.gsub(ANSI_REGEX) do |_match|
+        code = ::Regexp.last_match(1)
+
+        if code == "0"
+          # Reset - close all open spans
+          if stack.empty?
+            ""
+          else
+            spans = CLOSING_SPAN * stack.length
+            stack.clear
+            spans
+          end
+        elsif (template = HTML_TEMPLATES[code])
+          # Add span for this color/attribute
+          stack.push(code)
+          template
+        else
+          # Unknown code, ignore
+          ""
+        end
+      end
+
+      # Close any remaining open spans using string multiplication (faster than map/join)
+      result += CLOSING_SPAN * stack.length if stack.any?
+
+      result.html_safe
+    end
+  end
+end

data/app/models/onlylogs/application_record.rb

@@ -0,0 +1,5 @@
+module Onlylogs
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/onlylogs/batch_sender.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Onlylogs
+  class BatchSender
+    def initialize(channel, interval: 0.05)
+      @channel = channel
+      @interval = interval
+      @buffer = []
+      @mutex = Mutex.new
+      @running = false
+      @sender_thread = nil
+    end
+
+    def start
+      return if @running
+
+      @running = true
+      @sender_thread = Thread.new do
+        while @running
+          send_batch
+          sleep(@interval)
+        end
+      end
+    end
+
+    def stop
+      return unless @running
+
+      @running = false
+      @sender_thread&.join(0.1)
+      
+      # Send any remaining lines
+      send_batch
+    end
+
+    def add_line(line_data)
+      @mutex.synchronize do
+        @buffer << line_data
+      end
+    end
+
+    private
+
+    def send_batch
+      lines_to_send = nil
+      
+      @mutex.synchronize do
+        return if @buffer.empty?
+        lines_to_send = @buffer.dup
+        @buffer.clear
+      end
+      
+      return if lines_to_send.empty?
+
+      @channel.send(:transmit, {
+        action: "append_logs",
+        lines: lines_to_send
+      })
+    end
+  end
+end

data/app/models/onlylogs/file.rb

@@ -0,0 +1,151 @@
+module Onlylogs
+  class Error < StandardError; end
+
+  class File
+    attr_reader :path, :last_position, :last_line_number
+
+    def initialize(path, last_position: 0)
+      self.path = path
+      self.last_position = last_position
+      self.last_line_number = 0
+      validate!
+    end
+
+    def go_to_position(position)
+      return if position < 0
+
+      self.last_position = position
+      self.last_line_number = 0
+    end
+
+    def watch(&block)
+      # return enum_for(:watch) unless block
+
+      loop do
+        sleep 0.5
+
+        new_lines = read_new_lines
+        next if new_lines.empty?
+
+        yield new_lines
+      end
+    end
+
+    def size
+      ::File.size(path)
+    end
+
+    def exist?
+      ::File.exist?(path)
+    end
+
+    def text_file?
+      self.class.text_file?(path)
+    end
+
+    def self.text_file?(path)
+      return false unless ::File.exist?(path)
+      return false if ::File.zero?(path)
+
+      # Read first chunk and check for null bytes (binary indicator)
+      ::File.open(path, "rb") do |file|
+        chunk = file.read(8192) || ""
+        # If it contains null bytes, it's likely binary
+        return false if chunk.include?("\x00")
+      end
+
+      true
+    end
+
+    def grep(filter, regexp_mode: false, start_position: 0, end_position: nil, &block)
+      Grep.grep(filter, path, regexp_mode: regexp_mode, start_position: start_position, end_position: end_position) do |line_number, content|
+        yield Onlylogs::LogLine.new(line_number, content)
+      end
+    end
+
+    private
+
+    attr_writer :path, :last_position, :last_line_number
+
+    def read_new_lines
+      return [] unless exist?
+
+      current_size = ::File.size(path)
+      return [] if current_size <= last_position
+
+      # Read new content from last_position to end of file
+      new_content = ""
+      ::File.open(path, "rb") do |file|
+        file.seek(last_position)
+        new_content = file.read
+      end
+
+      return [] if new_content.empty?
+
+      # Split into lines, handling incomplete lines
+      lines = new_content.lines(chomp: true)
+
+      # If we're not at the beginning of the file, check if we're at a line boundary
+      first_line_removed = false
+      if last_position > 0
+        # Read one character before to see if it was a newline
+        ::File.open(path, "rb") do |file|
+          file.seek(last_position - 1)
+          char_before = file.read(1)
+          # If the character before wasn't a newline, we're in the middle of a line
+          if char_before != "\n" && lines.any?
+            # Remove the first line as it's incomplete
+            lines.shift
+            first_line_removed = true
+          end
+        end
+      end
+
+      # Check if the last line is complete (ends with newline)
+      last_line_incomplete = lines.any? && !new_content.end_with?("\n")
+      if last_line_incomplete
+        # Remove the last line as it's incomplete
+        lines.pop
+      end
+
+      # Update position to end of last complete line
+      if lines.any?
+        # Find the position after the last complete line
+        ::File.open(path, "rb") do |file|
+          file.seek(last_position)
+          # Read and count newlines to find where complete lines end
+          newline_count = 0
+          # If we removed the first line, we need to count one extra newline
+          # to account for the incomplete first line
+          target_newlines = lines.length + (first_line_removed ? 1 : 0)
+          while newline_count < target_newlines
+            char = file.read(1)
+            break unless char
+
+            newline_count += 1 if char == "\n"
+          end
+          self.last_position = file.tell
+        end
+      elsif last_line_incomplete
+        # If we had lines but removed the last incomplete one,
+        # position should be at the start of the incomplete line
+        self.last_position = current_size - new_content.lines.last.length
+      elsif first_line_removed
+        # If we removed the first line but have no complete lines,
+        # position should be at the end of the file since we consumed all content
+        self.last_position = current_size
+      else
+        # No lines at all, position at end of file
+        self.last_position = current_size
+      end
+
+      lines = lines.map.with_index { |line, index| Onlylogs::LogLine.new(self.last_line_number + index, line) }
+      self.last_line_number += lines.length
+      lines
+    end
+
+    def validate!
+      raise Error, "File not found: #{path}" unless exist?
+    end
+  end
+end

data/app/models/onlylogs/file_path_parser.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "uri"
+
+# kudos to https://github.com/BetterErrors/better_errors for this code!
+module Onlylogs
+  class FilePathParser
+    KNOWN_EDITORS = [
+      { symbols: [ :atom ], sniff: /atom/i, url: "atom://core/open/file?filename=%{file}&line=%{line}" },
+      { symbols: [ :emacs, :emacsclient ], sniff: /emacs/i, url: "emacs://open?url=file://%{file}&line=%{line}" },
+      { symbols: [ :idea ], sniff: /idea/i, url: "idea://open?file=%{file}&line=%{line}" },
+      { symbols: [ :macvim, :mvim ], sniff: /vim/i, url: "mvim://open?url=file://%{file_unencoded}&line=%{line}" },
+      { symbols: [ :rubymine ], sniff: /mine/i, url: "x-mine://open?file=%{file}&line=%{line}" },
+      { symbols: [ :sublime, :subl, :st ], sniff: /subl/i, url: "subl://open?url=file://%{file}&line=%{line}" },
+      { symbols: [ :textmate, :txmt, :tm ], sniff: /mate/i, url: "txmt://open?url=file://%{file}&line=%{line}" },
+      { symbols: [ :vscode, :code ], sniff: /code/i, url: "vscode://file/%{file}:%{line}" },
+      { symbols: [ :vscodium, :codium ], sniff: /codium/i, url: "vscodium://file/%{file}:%{line}" }
+    ].freeze
+
+    # Pre-compiled regex for better performance
+    FILE_PATH_PATTERN = %r{
+      (?<![a-zA-Z0-9_/])  # Negative lookbehind - not preceded by word chars or /
+      (?:\./)?             # Optional relative path indicator
+      (?:/[a-zA-Z0-9_\-\.\s]+)+  # File path with allowed characters
+      (?:\.rb|\.js|\.ts|\.tsx|\.jsx|\.py|\.java|\.go|\.rs|\.php|\.html|\.erb|\.haml|\.slim|\.css|\.scss|\.sass|\.less|\.xml|\.json|\.yml|\.yaml|\.md|\.txt|\.log)  # File extensions
+      (?::\d+)?            # Optional line number
+      (?![a-zA-Z0-9_/])    # Negative lookahead - not followed by word chars or /
+    }x.freeze
+
+    # Pre-built HTML template to avoid string interpolation
+    HTML_TEMPLATE = '<a href="%{url}" class="file-link">%{match}</a>'.freeze
+
+    def self.parse(string)
+      return string if string.blank?
+
+      # Early return if no file paths present
+      return string unless string.match?(FILE_PATH_PATTERN)
+
+      string.gsub(FILE_PATH_PATTERN) do |match|
+        file_path = extract_file_path(match)
+        line_number = extract_line_number(match)
+        url = cached_editor_instance.url(file_path, line_number)
+        HTML_TEMPLATE % { url: url, match: match }
+      end
+    end
+
+    def self.for_formatting_string(formatting_string)
+      new proc { |file, line|
+        formatting_string % { file: URI.encode_www_form_component(file), file_unencoded: file, line: line }
+      }
+    end
+
+    def self.for_proc(url_proc)
+      new url_proc
+    end
+
+    # Cache for the editor instance
+    @cached_editor_instance = nil
+
+    def self.cached_editor_instance
+      return @cached_editor_instance if @cached_editor_instance      
+      @cached_editor_instance = editor_from_symbol(Onlylogs.editor)      
+    end
+    
+
+    def self.editor_from_symbol(symbol)
+      KNOWN_EDITORS.each do |preset|
+        return for_formatting_string(preset[:url]) if preset[:symbols].include?(symbol)
+      end
+      editor_from_symbol(:vscode)
+    end
+
+    def initialize(url_proc)
+      @url_proc = url_proc
+    end
+
+    def url(raw_path, line)
+      if virtual_path && raw_path.start_with?(virtual_path)
+        if host_path
+          file = raw_path.sub(%r{\A#{virtual_path}}, host_path)
+        else
+          file = raw_path.sub(%r{\A#{virtual_path}/}, "")
+        end
+      else
+        file = raw_path
+      end
+
+      url_proc.call(file, line)
+    end
+
+    def scheme
+      url("/fake", 42).sub(/:.*/, ":")
+    end
+
+    private
+
+    attr_reader :url_proc
+
+    def virtual_path
+      @virtual_path ||= ENV["ONLYLOGS_VIRTUAL_PATH"]
+    end
+
+    def host_path
+      @host_path ||= ENV["ONLYLOGS_HOST_PATH"]
+    end
+
+    def self.extract_file_path(match)
+      # Remove line number if present
+      match.sub(/:\d+$/, "")
+    end
+
+    def self.extract_line_number(match)
+      # Extract line number or default to 1
+      line_match = match.match(/:(\d+)$/)
+      line_match ? line_match[1].to_i : 1
+    end
+  end
+end

data/app/models/onlylogs/grep.rb

@@ -0,0 +1,54 @@
+module Onlylogs
+  class Grep
+    def self.grep(pattern, file_path, start_position: 0, end_position: nil, regexp_mode: false, &block)
+      # Use the appropriate script based on configuration
+      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", Onlylogs.max_line_matches.to_s ] if Onlylogs.max_line_matches.present?
+      command_args << "--regexp" if regexp_mode
+
+      # Add byte range parameters if specified
+      if start_position > 0 || end_position
+        command_args << "--start-position" << start_position.to_s
+        command_args << "--end-position" << end_position.to_s if end_position
+      end
+
+      command_args += [ pattern, file_path ]
+
+      results = []
+
+      IO.popen(command_args, err: "/dev/null") do |io|
+        io.each_line do |line|
+          # Parse each line as it comes in - super_grep returns grep output with line numbers (format: line_number:content)
+          if match = line.strip.match(/^(\d+):(.*)/)
+            line_number = match[1].to_i
+            content = match[2]
+
+            if block_given?
+              yield line_number, content
+            else
+              results << [ line_number, content ]
+            end
+          end
+        end
+      end
+
+      block_given? ? nil : results
+    end
+
+    def self.match_line?(line, string, regexp_mode: false)
+      # 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+/, " ")
+
+      if regexp_mode
+        normalized_line.match?(string)
+      else
+        normalized_line.match?(Regexp.escape(string))
+      end
+    end
+  end
+end

data/app/models/onlylogs/log_line.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Onlylogs
+  class LogLine
+    attr_reader :number, :text
+
+    def initialize(number, text)
+      @number = number
+      @text = text
+    end
+
+    def parsed_number
+      number.to_s.reverse.gsub(/(\d{3})(?=\d)/, "\\1'").reverse.rjust(7)
+    end
+
+    def parsed_text
+      FilePathParser.parse(AnsiColorParser.parse(ERB::Util.html_escape(text)))
+    end
+
+    def to_a
+      [number, text]
+    end
+  end
+end

data/app/models/onlylogs/secure_file_path.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Onlylogs
+  class SecureFilePath
+    class SecurityError < StandardError; end
+
+    def self.encrypt(file_path)
+      encryptor = ActiveSupport::MessageEncryptor.new(encryption_key)
+      encrypted = encryptor.encrypt_and_sign(file_path.to_s)
+      Base64.urlsafe_encode64(encrypted).tr("=", "")
+    rescue => e
+      Rails.logger.error "Onlylogs: Encryption failed for #{file_path}: #{e.message}"
+      raise SecurityError, "Encryption failed"
+    end
+
+    def self.decrypt(encrypted_path)
+      decoded = Base64.urlsafe_decode64(encrypted_path)
+      encryptor = ActiveSupport::MessageEncryptor.new(encryption_key)
+      encryptor.decrypt_and_verify(decoded)
+    rescue => e
+      Rails.logger.error "Onlylogs: Decryption failed: #{e.message}"
+      raise SecurityError, "Invalid encrypted file path"
+    end
+
+    private
+
+    def self.encryption_key
+      Rails.application.secret_key_base[0..31]
+    end
+  end
+end

data/app/views/home/show.html.erb

@@ -0,0 +1,10 @@
+<% content_for :head do %>
+  <meta http-equiv="refresh" content="5">
+<% end %>
+
+<p>
+<%= link_to "Check logs in Real Time", onlylogs.root_path, target: :_blank %>
+</p>
+
+<p>When loading this page, some lines are added to the logs, for testing purposes.</p>
+<p><em>This page refreshes automatically every 5 seconds.</em></p>

data/app/views/layouts/onlylogs/application.html.erb

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Onlylogs</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= javascript_importmap_tags "application", importmap: Onlylogs.importmap  %>
+  
+  <style>
+    html, body {
+      margin: 0;
+      padding: 0;
+      height: 100%;
+      width: 100%;
+      overflow: hidden;
+    }
+  </style>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

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

@@ -0,0 +1,49 @@
+<div class="sidebar-layout" data-controller="toggle-class" data-toggle-class-toggle-class="closed">
+  <aside id="sidebar">
+    <div class="sidebar-menu">
+      <%= link_to onlylogs.root_path, class: "btn sidebar-menu__button" do %>
+        <%= image_tag "onlylogs/logo.png" %>
+      <% end %>
+      <div class="sidebar-menu__content">
+        <div class="sidebar-menu__items">
+          <div class="sidebar-menu__group">
+            <div class="sidebar-menu__group-label">Projects</div>
+            <nav class="sidebar-menu__items">
+              <%= link_to "All Projects", root_path, class: "btn sidebar-menu__button" %>
+
+              <nav class="sidebar-menu__sub">
+                <nav class="sidebar-menu__sub text-sm">
+                    <div>
+                      <% if Onlylogs::File.text_file?(drain_file) %>
+                        <%= link_to drain_file.basename, project_path(@project, file_path: Onlylogs::SecureFilePath.encrypt(drain_file.to_s)) %>
+                      <% else %>
+                        <%= drain_file.basename %>
+                      <% end %>
+                      <small>(<%= number_to_human_size(File.size(drain_file)) %>)</small>
+                      <%= link_to project_drain_file_path(@project, Onlylogs::SecureFilePath.encrypt(drain_file.to_s)),
+                                  title: t('drain_files.show.title'),
+                                  class: 'download-link' do %>
+                        <i class="fa-regular fa-download" aria-label="<%= t('drain_files.show.title') %>"></i>
+                      <% end %>
+                    </div>
+                </nav>
+              </nav>
+            </nav>
+          </div>
+        </div>
+      </div>
+    </div>
+
+  </aside>
+  <main id="main">
+    <header class="flex items-center gap show@md">
+      <button type="button" class="btn btn--borderless p-1" data-action="toggle-class#toggle">
+        <i class="fa-regular fa-sidebar"></i>
+        <span class="sr-only">Toggle Sidebar</span>
+      </button>
+      <div class="separator-vertical mi-1" style="--sep-size: 1rem"></div>
+    </header>
+
+    <%= render partial: "onlylogs/shared/log_container", locals: { log_file_path: @log_file_path, tail: @max_lines, filter: @filter, autoscroll: @autoscroll } %>
+  </main>
+</div>