onlylogs 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f166264d89c5d2273751e3377ef236168da610b1d37d5ddf02d33959f2fe318d
-  data.tar.gz: a612d6738ee600171cd21a78b403d1abef06fdf5df893ebcc8c3401b092f6a51
+  metadata.gz: 4707246899a958c58bf6ea58aba6f21234d938c660ce23dbad8df598654a4b5c
+  data.tar.gz: c46cf3df22e80cd90749bf144f62a271a9556b13ee718640377aa86f34608e05
 SHA512:
-  metadata.gz: 6c2d38d16486ea48cd8e6c695e1b9234dbe8e300f45342afa163adfef2e532cdf1cf0cdecdca411c9a13a80c6c4f32aa5c33a82dfc9137c2da35f72cffa0f2c6
-  data.tar.gz: d4b8b016e5c089712e288d6533b613571f5edee524b2784a3aff80b4d8701913aabb169f72cdedb4220c01a86f3be33d0c52eedc644538db1a3fe3e259e947c9
+  metadata.gz: 7eabe1b6124704eee89f759001cb7df9bf8fa5bb71ad98ac9c26bbc091db38c93ee3c7fdb4b35729f33cc9eeb2d0ac3170b2d2ef11ae5b979b7ec454664bc435
+  data.tar.gz: fa8226aa140b44b8eac0f3a03000aac95615470343d90de827d98da79ba4045c776b052171b3555ef955db2747dc760640cd787f6207ae95f6e67e70e152dca1

data/README.md

@@ -58,6 +58,33 @@ Here you can grep your logs with regular expressions.
 > If ripgrep is not installed, onlylogs falls back to `grep`. 
 > A warning icon (⚠️) will be displayed in the toolbar when using `grep` to indicate slower search performance.
 
+## Logging in production
+
+Rails apps log to `STDOUT` in production and let the platform collect the stream.
+onlylogs keeps that default: `Onlylogs::HttpLogger.new` writes every line to `$stdout` and, when
+`ONLYLOGS_DRAIN_URL` is set, ships it to https://onlylogs.io as well. Nothing is written to disk.
+
+```ruby
+# config/environments/production.rb
+config.logger = Onlylogs::HttpLogger.new
+```
+
+Keep this default on an **ephemeral filesystem** (Heroku, Deploio, Docker, Kubernetes). A log file
+there is lost on every deploy and, while it grows, its page cache counts towards the container's
+memory limit: it shows up as a memory leak that resets on each release.
+
+If you have a **persistent disk** and want the files, for instance to browse them with the engine,
+pass a rotating log device as the local fallback. Rails rotates at 100 MB in development, which is a
+good size here too:
+
+```ruby
+# config/environments/production.rb
+log_file = Logger::LogDevice.new(Rails.root.join("log", "production.log"), shift_age: 5, shift_size: 100.megabytes)
+config.logger = Onlylogs::HttpLogger.new(local_fallback: log_file)
+```
+
+Any IO or log device works and is used as is. `Onlylogs::SocketLogger` accepts the same argument.
+
 ## Authentication
 
 Yes, we should do this right away, because this engine gives access to your log files, so you want to be sure.
@@ -235,7 +262,7 @@ end
 
 Onlylogs automatically detects file paths in log messages and converts them into clickable links that open in your preferred code editor.
 
-For a complete list of supported editors, see [lib/onlylogs/editor_detector.rb](lib/onlylogs/editor_detector.rb).
+For a complete list of supported editors, see [app/models/onlylogs/file_path_parser.rb](app/models/onlylogs/file_path_parser.rb).
 
 ```bash
 # env variables
@@ -294,7 +321,7 @@ The `Onlylogs::Formatter` supports a denylist: an array of regular expressions t
 
 ```ruby
 # config/environments/production.rb
-config.logger = Onlylogs::Logger.new(Rails.root.join("log", "production.log"))
+config.logger = Onlylogs::HttpLogger.new
 config.logger.formatter.denylist = [/health_check/, /ping/, /\.css\z/]
 ```
 
@@ -340,6 +367,16 @@ bin/continuous_log_writer 10 3
 
 The script will write logs to `test/dummy/log/development.log`, which will appear in real-time in the onlylogs UI at `http://localhost:3000/onlylogs`. 
 
+The lines are generated by `Onlylogs::ContinuousLogWriter`, in the same format a Rails app logging through `Onlylogs::Logger` produces. The script is a thin wrapper, so applications embedding onlylogs can reuse the writer against any file of their own:
+
+```ruby
+require "onlylogs/continuous_log_writer"
+
+Onlylogs::ContinuousLogWriter.new(some_log_path, logs_per_batch: 3, interval: 1).call
+```
+
+It is plain Ruby (it does not need Rails to be booted) and is not loaded by `require "onlylogs"` — require it explicitly where you need it.
+
 **Example workflow:**
 
 ```bash

data/app/channels/onlylogs/logs_channel.rb

@@ -16,27 +16,8 @@ module Onlylogs
       @last_initialize_params = data.dup
       cleanup_existing_operations
 
-      # Decrypt and verify the file path
-      begin
-        encrypted_file_path = data["file_path"]
-        if encrypted_file_path.present?
-          file_path = Onlylogs::SecureFilePath.decrypt(encrypted_file_path)
-
-          # Verify the decrypted path is still allowed
-          unless Onlylogs.file_path_permitted?(file_path)
-            Rails.logger.error "Onlylogs: Attempted to access non-allowed file: #{file_path}"
-            transmit({action: "error", content: "Access denied"})
-            return
-          end
-        else
-          # Fallback to default if no encrypted path provided
-          file_path = Onlylogs.default_log_file_path
-        end
-      rescue Onlylogs::SecureFilePath::SecurityError => e
-        Rails.logger.error "Onlylogs: Security violation - #{e.message}"
-        transmit({action: "error", content: "Access denied"})
-        return
-      end
+      file_path = authorized_file_path(data["file_path"])
+      return unless file_path
 
       # Check if the file is a text file
       unless Onlylogs::File.text_file?(file_path)
@@ -72,6 +53,32 @@ module Onlylogs
 
     private
 
+    # Decrypts and authorises the requested file. Returns nil (after transmitting
+    # an error) when there is no token, when it cannot be decrypted, or when the
+    # decrypted path is not on the configured allow-list — the three ways a client
+    # can ask for something it is not entitled to stream.
+    def authorized_file_path(encrypted_file_path)
+      if encrypted_file_path.blank?
+        Rails.logger.error "Onlylogs: initialize_watcher without a file path token; refusing to stream"
+        transmit({action: "error", content: "Access denied"})
+        return nil
+      end
+
+      file_path = Onlylogs::SecureFilePath.decrypt(encrypted_file_path)
+
+      unless Onlylogs.file_path_permitted?(file_path)
+        Rails.logger.error "Onlylogs: Attempted to access non-allowed file: #{file_path}"
+        transmit({action: "error", content: "Access denied"})
+        return nil
+      end
+
+      file_path
+    rescue Onlylogs::SecureFilePath::SecurityError => e
+      Rails.logger.error "Onlylogs: Security violation - #{e.message}"
+      transmit({action: "error", content: "Access denied"})
+      nil
+    end
+
     def cleanup_existing_operations
       if @batch_sender
         @batch_sender.stop(send_remaining_lines: false)
@@ -85,6 +92,10 @@ module Onlylogs
     # an explicit cursor (matches the default whole-file live-mode page load).
     LIVE_TAIL_BYTES = 10_000
 
+    # The button re-runs the viewer's own reset, which reopens the file at its current tail.
+    ROTATED_MESSAGE = 'The file was rotated. <button type="button" class="reload-button" ' \
+      'data-action="click->log-streamer#reset">Reload</button>'
+
     def start_log_watcher(file_path, filter = nil, regexp_mode = false)
       return if @log_watcher_running
 
@@ -123,6 +134,10 @@ module Onlylogs
               })
             end
           end
+
+          # watch returns on its own only when the file was rotated: nothing more will
+          # arrive under this name from where we are, so the viewer has to start over.
+          transmit({action: "finish", content: ROTATED_MESSAGE}) if @log_watcher_running
         end
       rescue => e
         Rails.logger.error "Log watcher error: #{e.message}"
@@ -168,56 +183,18 @@ module Onlylogs
         last_byte_offset = nil
         line_count = 0
 
-        Rails.logger.silence(Logger::ERROR) do
-          skip_first = start_position > 0
-
-          if filter.present?
-            # Use grep for filtered search
-            @log_file.grep(filter, regexp_mode: regexp_mode, start_position: start_position,
-              end_position: end_position, timeout: Onlylogs.search_timeout) do |result|
-              break if @batch_sender.nil? || @log_watcher_running == false
-
-              # Skip first line if start_position > 0 (line is cut off at byte boundary)
-              if skip_first
-                skip_first = false
-                next
-              end
+        show_expand_button = filter.present?
 
-              # Result is a hash with {byte_offset, content}
-              byte_offset = result[:byte_offset]
-              log_line = result[:content]
-
-              # Buffer previous line and skip it to avoid cut-off lines at boundaries
-              if last_line
-                @batch_sender.add_line(render_log_line(last_line, byte_offset: last_byte_offset, show_expand_button: true))
-                line_count += 1
-              end
-              last_line = log_line
-              last_byte_offset = byte_offset
-            end
-          else
-            # No filter - read all lines directly (skip grep)
-            # Still need byte_offset for highlighting when expanding around a line
-            current_byte_offset = start_position
-            read_byte_range(file_path, start_position, end_position) do |log_line|
-              break if @batch_sender.nil? || @log_watcher_running == false
-
-              # Skip first line if start_position > 0 (line is cut off at byte boundary)
-              if skip_first
-                skip_first = false
-                next
-              end
-
-              # Buffer previous line and skip it to avoid cut-off lines at boundaries
-              if last_line
-                @batch_sender.add_line(render_log_line(last_line, byte_offset: last_byte_offset))
-                line_count += 1
-              end
-              last_line = log_line
-              last_byte_offset = current_byte_offset
-              # Account for line content plus newline character (2 bytes for \r\n or 1 for \n)
-              current_byte_offset += log_line.bytesize + 1
+        Rails.logger.silence(Logger::ERROR) do
+          each_matching_line(file_path, filter, regexp_mode, start_position, end_position) do |log_line, byte_offset|
+            # Buffer previous line and skip it to avoid cut-off lines at boundaries
+            if last_line
+              @batch_sender.add_line(render_log_line(last_line, byte_offset: last_byte_offset,
+                show_expand_button: show_expand_button))
+              line_count += 1
             end
+            last_line = log_line
+            last_byte_offset = byte_offset
           end
         end
 
@@ -249,6 +226,49 @@ module Onlylogs
       end
     end
 
+    # Yields [line, byte_offset] over the requested slice: through grep when there
+    # is a filter, straight off disk when there is not. Either way the offsets are
+    # the real ones, so "show around this line" can re-centre on them.
+    #
+    # A range that starts mid-line opens with a fragment of a line, which is
+    # dropped - but its bytes still count towards every offset after it.
+    def each_matching_line(file_path, filter, regexp_mode, start_position, end_position)
+      skip_first = start_position > 0
+
+      if filter.present?
+        @log_file.grep(filter, regexp_mode: regexp_mode, start_position: start_position,
+          end_position: end_position, timeout: Onlylogs.search_timeout) do |result|
+          break if reading_stopped?
+
+          if skip_first
+            skip_first = false
+            next
+          end
+
+          yield result[:content], result[:byte_offset]
+        end
+      else
+        offset = start_position
+
+        read_byte_range(file_path, start_position, end_position) do |log_line, raw_bytesize|
+          break if reading_stopped?
+
+          if skip_first
+            skip_first = false
+            offset += raw_bytesize
+            next
+          end
+
+          yield log_line, offset
+          offset += raw_bytesize
+        end
+      end
+    end
+
+    def reading_stopped?
+      @batch_sender.nil? || @log_watcher_running == false
+    end
+
     def read_byte_range(file_path, start_position, end_position)
       file_size = ::File.size(file_path)
       range_size = (end_position || file_size) - start_position
@@ -256,7 +276,7 @@ module Onlylogs
       return if start_position < 0 || range_size <= 0 || start_position >= file_size
 
       ::File.read(file_path, range_size, start_position).each_line do |line|
-        yield line.chomp
+        yield line.chomp, line.bytesize
       end
     rescue => e
       Rails.logger.error "Error reading byte range: #{e.message}"

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

@@ -1,7 +1,7 @@
 import { Controller } from "@hotwired/stimulus"
 
 export default class KeyboardShortcutsController extends Controller {
-  static targets = ["liveMode", "autoscroll"]
+  static targets = ["liveButton", "searchButton", "autoscroll"]
 
   connect() {
     this.boundHandleKeydown = this.handleKeydown.bind(this)
@@ -13,15 +13,25 @@ export default class KeyboardShortcutsController extends Controller {
   }
 
   handleKeydown(event) {
+    // These are bare single-key shortcuts. Any modifier means the keystroke belongs
+    // to the browser or the OS (cmd+L, cmd+A, cmd+S) and must pass straight through.
+    if (event.metaKey || event.ctrlKey || event.altKey) {
+      return
+    }
+
     // Only handle shortcuts when not typing in input fields
-    if (event.target.tagName === 'INPUT' || event.target.tagName === 'TEXTAREA') {
+    if (event.target.tagName === 'INPUT' || event.target.tagName === 'TEXTAREA' || event.target.isContentEditable) {
       return
     }
 
     switch (event.key.toLowerCase()) {
       case 'l':
         event.preventDefault()
-        this.toggleLiveMode()
+        if (this.hasLiveButtonTarget) this.liveButtonTarget.click()
+        break
+      case 's':
+        event.preventDefault()
+        if (this.hasSearchButtonTarget) this.searchButtonTarget.click()
         break
       case 'a':
         event.preventDefault()
@@ -30,15 +40,9 @@ export default class KeyboardShortcutsController extends Controller {
     }
   }
 
-  toggleLiveMode() {
-    if (this.hasLiveModeTarget) {
-      this.liveModeTarget.checked = !this.liveModeTarget.checked
-      this.liveModeTarget.dispatchEvent(new Event('change', { bubbles: true }))
-    }
-  }
-
   toggleAutoscroll() {
-    if (this.hasAutoscrollTarget) {
+    // Autoscroll only exists while live; ignore the shortcut when it is not on screen.
+    if (this.hasAutoscrollTarget && this.autoscrollTarget.offsetParent !== null) {
       this.autoscrollTarget.checked = !this.autoscrollTarget.checked
       this.autoscrollTarget.dispatchEvent(new Event('change', { bubbles: true }))
     }