onlylogs 0.4.6 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6cd6af6ff916e3ce2fb4ad8d4cf77518b681b86246f7c662390e8e66acadc10
-  data.tar.gz: 88b5108172130b635097dcad9c1fa55bd377e59f62d8ee0acbffd3b51c203404
+  metadata.gz: 43e963f2acccbac4061747abd2606eb298b7ea138404f6e726e03c7a5ffacb4e
+  data.tar.gz: c9ee6fb1e854dffddb634be9153d285c8db88836b8a2f7046b63f0a8f0734cfa
 SHA512:
-  metadata.gz: 4d4d33d4063e8bdd61e436f92ad5fe1156693003a98bbc6a7debcc8d0a954fcd77f980222f88c0f7181c20b5fd5f2aa073504df37f22a3dfc08159bfba4c0a3a
-  data.tar.gz: 1eb8bf75d9c8b6f241b08009797d3db0b6c806319b57d69982c85eeb537eb6103904f323664e752f87bbc1ea97938300e11c8912ca951adbf81784ed130bde91
+  metadata.gz: 0cf479d9e32a82adb41090a4e4525c4f237e75f7ab52485ac29ce8db5cfaf77fada2434dc675078afabf660ee4d3bf1470f916c13976a3cc11ca5823eb041bbe
+  data.tar.gz: 955aa49574feaa833e135a853145858961514ebe4c4a093a3758410b1ad91c5aaa6218f09c4944b29360c0419f9bddd738d4c25b48e99e70b882e95b56b2be60

data/README.md

@@ -290,38 +290,93 @@ You are more than welcome to help and contribute to this package.
 
 The app uses minitest and includes a dummy app, so getting started should be straightforward.
 
+### Getting Started
+
+First, install dependencies:
+
+```bash
+bundle install
+```
+
+Then start the dummy Rails app:
+
+```bash
+cd test/dummy
+bundle exec rails s
+```
+
+The dummy app will be available at `http://localhost:3000` and onlylogs at `http://localhost:3000/onlylogs`.
+
+### Generating Test Logs
+
+To test onlylogs with live log data, use the continuous log writer script. This is especially useful for testing real-time log streaming and UI behavior.
+
+```bash
+# Generate 1 log entry every 2 seconds (default)
+bin/continuous_log_writer
+
+# Generate 5 log entries every 1 second
+bin/continuous_log_writer 5 1
+
+# Generate 10 log entries every 3 seconds
+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`. 
+
+**Example workflow:**
+
+```bash
+# Terminal 1: Start the Rails app
+cd test/dummy && bundle exec rails s
+
+# Terminal 2: Generate test logs while viewing in the UI
+bin/continuous_log_writer 3 1
+```
+
+Open `http://localhost:3000/onlylogs` in your browser and watch logs appear as the script writes them.
+
 ### Latency Simulation
 
 For testing how onlylogs behaves under production-like network conditions, you can simulate latency for HTTP requests and WebSocket connections using the included latency simulation tool.
 
-### Usage
+**Parameters:**
+- **Latency** (default: 120ms): The base network delay added to all traffic
+- **Jitter** (default: 30ms): Random variation (±) applied to the latency (changes every 2 seconds to simulate real network conditions)
+- **Port** (default: 3000): The port to apply latency simulation to
+
+**Common scenarios:**
 
 ```bash
-# Enable latency simulation (120±30ms jitter on port 3000)
-./bin/simulate_latency enable
+# Default: 120ms ±30ms jitter (simulates typical 4G/LTE conditions)
+bin/simulate_latency enable
 
-# Enable custom latency simulation (150±30ms jitter on port 3000)
-./bin/simulate_latency enable 150
+# High latency: 500ms (simulates poor connectivity)
+bin/simulate_latency enable 500
 
-# Enable custom latency and jitter (200±50ms jitter on port 3000)
-./bin/simulate_latency enable 200/50
+# High latency with high variation: 300ms ±100ms (simulates unstable connections)
+bin/simulate_latency enable 300/100
 
-# Enable latency simulation on custom port (120±30ms jitter on port 8080)
-./bin/simulate_latency enable -p 8080
+# Custom port: 120ms ±30ms on port 8080
+bin/simulate_latency enable -p 8080
+```
 
-# Enable custom latency and jitter on custom port (150±50ms jitter on port 8080)
-./bin/simulate_latency enable 150/50 -p 8080
 
-# Test the latency
-./bin/simulate_latency test
+**Testing and monitoring:**
 
-# Check current status
-./bin/simulate_latency status
+```bash
+# Test the current latency configuration
+bin/simulate_latency test
+
+# Check current status and active pipes
+bin/simulate_latency status
 
-# Disable and clean up
-./bin/simulate_latency disable
+# Disable and restore normal network conditions
+bin/simulate_latency disable
 ```
 
+The `test` command will run 10 HTTP requests and 10 WebSocket connections, showing you the actual round-trip times and helping you verify the latency is working as expected.
+
 ### Performance Testing
 
 Performance tests require large log files that are not included in the repository. You can download them using the provided script:

data/app/controllers/onlylogs/logs_controller.rb

@@ -10,20 +10,38 @@ module Onlylogs
 
       @filter = params[:filter]
       @autoscroll = params[:autoscroll] != "false"
+      @regexp_mode = params[:regexp_mode] == "true"
       @mode = @filter.blank? ? (params[:mode] || "live") : "search" # "live" or "search"
     end
 
+    def download
+      if params[:log_file_path].blank?
+        return render(plain: "Bad Request: missing required parameter 'log_file_path' (encrypted log file path).", status: :bad_request)
+      end
+
+      file_path = authorized_log_file_path(params[:log_file_path])
+      send_file file_path, filename: ::File.basename(file_path), disposition: :attachment
+    rescue Onlylogs::SecureFilePath::SecurityError
+      render plain: "Bad Request: 'log_file_path' could not be decrypted (tampered or malformed token).", status: :bad_request
+    rescue Onlylogs::ForbiddenPathError
+      render plain: "Forbidden: requested log file path is not in the allowed list.", status: :forbidden
+    rescue ActionController::MissingFile, Errno::ENOENT
+      render plain: "Not Found: log file is currently unreadable (it may have been rotated, moved, or temporarily unavailable).", status: :not_found
+    end
+
     private
 
     def selected_log_file_path
-      encrypted_path = params[:log_file_path]
-      return default_log_file_path if encrypted_path.blank?
+      return default_log_file_path if params[:log_file_path].blank?
+      authorized_log_file_path(params[:log_file_path])
+    end
 
+    def authorized_log_file_path(encrypted_path)
       decrypted_path = Onlylogs::SecureFilePath.decrypt(encrypted_path)
       if Onlylogs.file_path_permitted?(decrypted_path)
         decrypted_path
       else
-        raise SecurityError, "File path not allowed"
+        raise Onlylogs::ForbiddenPathError, "File path not allowed"
       end
     end
 

data/app/helpers/onlylogs/application_helper.rb

@@ -1,4 +1,7 @@
 module Onlylogs
   module ApplicationHelper
+    def log_file_label(file)
+      Pathname.new(file).relative_path_from(Rails.root).to_s
+    end
   end
 end

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

@@ -12,7 +12,7 @@ export default class LogStreamerController extends Controller {
     regexpMode: { type: Boolean, default: false }
   };
 
-  static targets = ["logLines", "filterInput", "results", "liveMode", "message", "regexpMode", "websocketStatus", "stopButton", "clearButton"];
+  static targets = ["logLines", "filterInput", "results", "liveMode", "message", "regexpMode", "websocketStatus", "stopButton", "clearButton", "autoscroll"];
 
   connect() {
     this.consumer = createConsumer();
@@ -86,11 +86,29 @@ export default class LogStreamerController extends Controller {
 
   toggleAutoScroll() {
     this.autoScrollValue = !this.autoScrollValue;
+    this.#updateUrlParam('autoscroll', this.autoScrollValue ? null : 'false');
     this.scroll();
   }
 
+  pauseForSelection() {
+    // Triggered by TextSelectionController#handleMouseDown via text-selection:start event
+    // Enter "highlighting mode" - disable both autoscroll and live mode
+    if (this.autoScrollValue) {
+      this.autoScrollValue = false;
+      this.autoscrollTarget.checked = false;
+    }
+
+    if (this.isLiveMode()) {
+      this.liveModeTarget.checked = false;
+      this.modeValue = 'search';
+      this.updateLiveModeState();
+      this.stop();
+    }
+  }
+
   toggleRegexpMode() {
     this.regexpModeValue = this.regexpModeTarget.checked;
+    this.#updateUrlParam('regexp_mode', this.regexpModeValue ? 'true' : null);
     // If we have a filter applied, reconnect to apply the new regexp mode
     if (this.filterInputTarget.value && this.filterInputTarget.value.trim() !== '') {
       this.reconnectWithNewMode();
@@ -100,20 +118,22 @@ export default class LogStreamerController extends Controller {
   toggleLiveMode() {
     // this condition looks revered, but the value here has been changed already. so the live mode has been enabled.
     if (this.isLiveMode()) {
-      this.clearFilter();
       this.modeValue = 'live';
-      this.reconnectWithNewMode();
-      return;
-    }
-    else {
+      this.updateLiveModeState();
+      if (!this.isRunning) {
+        this.start();
+      }
+    } else {
+      // Prevent unchecking - live mode can only be disabled by applying a filter
       this.liveModeTarget.checked = true;
-      return false;
     }
   }
 
   applyFilter() {
+    const filterValue = this.filterInputTarget.value;
+
     // If filter is applied, disable live mode
-    if (this.filterInputTarget.value && this.filterInputTarget.value.trim() !== '') {
+    if (filterValue && filterValue.trim() !== '') {
       this.liveModeTarget.checked = false;
       this.modeValue = 'search';
     } else {
@@ -125,6 +145,7 @@ export default class LogStreamerController extends Controller {
     // Update visual state
     this.updateLiveModeState();
     this.updateStopButtonVisibility();
+    this.#updateUrlParam('filter', filterValue || null);
 
     // Use the global debounced reconnection (300ms delay)
     this.reconnectWithNewMode();
@@ -168,6 +189,9 @@ export default class LogStreamerController extends Controller {
     this.updateLiveModeState();
     this.updateStopButtonVisibility();
 
+    // Update URL with cleared filter
+    this.#updateUrlParam('filter');
+
     // Reconnect with cleared filter and live mode
     this.reconnectWithNewMode();
   }
@@ -184,11 +208,14 @@ export default class LogStreamerController extends Controller {
 
   updateLiveModeState() {
     const liveModeLabel = this.liveModeTarget.closest('label');
+    const hasFilter = this.filterInputTarget.value && this.filterInputTarget.value.trim() !== '';
 
-    if (this.isLiveMode()) {
-      liveModeLabel.classList.remove('live-mode-sticky');
-    } else {
+    if (hasFilter) {
       liveModeLabel.classList.add('live-mode-sticky');
+      this.liveModeTarget.disabled = true;
+    } else {
+      liveModeLabel.classList.remove('live-mode-sticky');
+      this.liveModeTarget.disabled = false;
     }
   }
 
@@ -390,4 +417,17 @@ export default class LogStreamerController extends Controller {
     this.clusterize = null;
     this.#initializeClusterize();
   }
+
+  #updateUrlParam(param, value = null) {
+    const params = new URLSearchParams(window.location.search);
+
+    if (value != null) {
+      params.set(param, value);
+    } else {
+      params.delete(param);
+    }
+
+    const newUrl = `${window.location.pathname}?${params.toString()}`;
+    window.history.replaceState(null, '', newUrl);
+  }
 }

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

@@ -7,19 +7,26 @@ export default class TextSelectionController extends Controller {
     this.boundHandleTextSelection = this.handleTextSelection.bind(this)
     this.boundHandleDocumentClick = this.handleDocumentClick.bind(this)
     this.boundHandleSelectionChange = this.handleSelectionChange.bind(this)
-    
+    this.boundHandleMouseDown = this.handleMouseDown.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)
     document.addEventListener('click', this.boundHandleDocumentClick)
     document.addEventListener('selectionchange', this.boundHandleSelectionChange)
   }
 
   disconnect() {
+    this.logLinesTarget.removeEventListener('mousedown', this.boundHandleMouseDown)
     this.logLinesTarget.removeEventListener('mouseup', this.boundHandleTextSelection)
     document.removeEventListener('click', this.boundHandleDocumentClick)
     document.removeEventListener('selectionchange', this.boundHandleSelectionChange)
   }
 
+  handleMouseDown() {
+    this.dispatch("start")
+  }
+
   handleTextSelection(event) {
     const selection = window.getSelection()
     const selectedText = selection.toString().trim()

data/app/models/onlylogs/secure_file_path.rb

@@ -5,7 +5,6 @@ module Onlylogs
     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
@@ -15,15 +14,14 @@ module Onlylogs
 
     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_class_method def self.encryption_key
-      Rails.application.secret_key_base[0..31]
+    private_class_method def self.encryptor
+      @encryptor ||= ActiveSupport::MessageEncryptor.new(Rails.application.secret_key_base[0..31])
     end
   end
 end

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

@@ -14,6 +14,10 @@
     .log-file-dropdown {
         margin-left: 0.5rem;
     }
+
+    .download-link {
+        margin-left: 0.5rem;
+    }
 </style>
 <div class="grid">
   <div class="grid-header">
@@ -21,15 +25,16 @@
       <%= form_with url: root_path, method: :get, local: true, class: "log-file-dropdown", data: { controller: "auto-submit" } do %>
         <select id="log_file_path" name="log_file_path" data-action="change->auto-submit#submit">
           <% @available_log_files.each do |file| %>
-            <% encrypted_path = Onlylogs::SecureFilePath.encrypt(file.to_s) %>
-            <% relative_path = Pathname.new(file).relative_path_from(Rails.root).to_s %>
-            <option value="<%= encrypted_path %>" <%= "selected" if file.to_s == @log_file_path.to_s %>>
-              <%= relative_path %>
+            <option value="<%= Onlylogs::SecureFilePath.encrypt(file) %>" <%= "selected" if file.to_s == @log_file_path.to_s %>>
+              <%= log_file_label(file) %>
             </option>
           <% end %>
         </select>
       <% end %>
+      <% if @log_file_path %>
+        <%= link_to "Download", download_log_path(log_file_path: Onlylogs::SecureFilePath.encrypt(@log_file_path)), class: "download-link" %>
+      <% end %>
     <% end %>
   </div>
-  <%= render partial: "onlylogs/shared/log_container", locals: { log_file_path: @log_file_path, tail: @max_lines, filter: @filter, autoscroll: @autoscroll } %>
+  <%= render partial: "onlylogs/shared/log_container", locals: { log_file_path: @log_file_path, tail: @max_lines, filter: @filter, autoscroll: @autoscroll, regexp_mode: @regexp_mode } %>
 </div>

data/app/views/onlylogs/shared/_log_container.html.erb

@@ -1,4 +1,4 @@
-<%# locals: (log_file_path:, tail: 100, filter: "", autoscroll: true) %>
+<%# locals: (log_file_path:, tail: 100, filter: "", autoscroll: true, regexp_mode: false) %>
 <script nonce="<%= request.content_security_policy_nonce %>"
         src="https://cdn.jsdelivr.net/npm/clusterize.js@0.18.1/clusterize.min.js"></script>
 <%= render "onlylogs/shared/log_container_styles" %>
@@ -17,7 +17,9 @@
      data-log-streamer-cursor-position-value="<%= cursor_position %>"
      data-log-streamer-filter-value="<%= filter %>"
      data-log-streamer-auto-scroll-value="<%= autoscroll %>"
+     data-log-streamer-regexp-mode-value="<%= regexp_mode %>"
      data-log-streamer-mode-value="<%= mode %>"
+     data-action="text-selection:start->log-streamer#pauseForSelection"
      class="onlylogs-log-container" >
     <div data-log-streamer-target="logLines" data-text-selection-target="logLines" id="scrollArea" class="onlylogs-log-lines clusterize-scroll">
       <div id="contentArea" class="clusterize-content">
@@ -42,13 +44,13 @@
         </div>
         <div>
           <label style="margin-bottom: 0;">
-            <input id="autoscroll" type="checkbox" <%= autoscroll ? "checked" : "" %> name="autoscroll" data-keyboard-shortcuts-target="autoscroll" data-action="change->log-streamer#toggleAutoScroll">
+            <input id="autoscroll" type="checkbox" <%= autoscroll ? "checked" : "" %> name="autoscroll" data-log-streamer-target="autoscroll" data-keyboard-shortcuts-target="autoscroll" data-action="change->log-streamer#toggleAutoScroll">
             <u>A</u>utoscroll
           </label>
         </div>
         <div>
           <label style="margin-bottom: 0;">
-            <input id="regexpMode" type="checkbox" name="regexpMode" data-log-streamer-target="regexpMode" data-text-selection-target="regexpMode" data-action="change->log-streamer#toggleRegexpMode">
+            <input id="regexpMode" type="checkbox" <%= regexp_mode ? "checked" : "" %> name="regexpMode" data-log-streamer-target="regexpMode" data-text-selection-target="regexpMode" data-action="change->log-streamer#toggleRegexpMode">
             <u>R</u>egexp Mode
           </label>
         </div>

data/config/routes.rb

@@ -1,4 +1,5 @@
 Onlylogs::Engine.routes.draw do
   root "logs#index"
   resources :logs, only: [:index]
+  get "download", to: "logs#download", as: :download_log
 end

data/lib/onlylogs/http_logger.rb

@@ -7,24 +7,52 @@ require "uri"
 # Unlike SocketLogger, it does not require a sidecar process or Puma plugin,
 # so it works from any process: Puma, GoodJob, Sidekiq, rake tasks, migrations, etc.
 
+# When the drain is unreachable or unresponsive, we do two things to protect the app:
+# * an upper bound to the in-memory queue: log lines can never accumulate without limit and
+#   exhaust memory
+# * cooldown: once the drain is known to be failing we stop attempting
+#   requests for a cooldown period instead of blocking on every send for the full
+#   read timeout (a down host accepts the TCP/TLS connection but never answers).
 module Onlylogs
   class HttpLogger < Onlylogs::Logger
     DEFAULT_BATCH_SIZE = 100
     DEFAULT_FLUSH_INTERVAL = 0.5
+    DEFAULT_MAX_QUEUE_SIZE = 10_000
+
+    # Keep timeouts short: a single slow/dead drain must never stall the app for long.
+    DEFAULT_OPEN_TIMEOUT = 0.5
+    DEFAULT_READ_TIMEOUT = 0.5
+
+    # Open the circuit after this many consecutive failed sends
+    CIRCUIT_FAILURE_THRESHOLD = 3
+    # ...and keep it open for this long once it is open.
+    CIRCUIT_COOLDOWN = 30
 
     def initialize(
       local_fallback: $stdout,
       drain_url: ENV["ONLYLOGS_DRAIN_URL"],
       batch_size: ENV.fetch("ONLYLOGS_BATCH_SIZE", DEFAULT_BATCH_SIZE).to_i,
-      flush_interval: ENV.fetch("ONLYLOGS_FLUSH_INTERVAL", DEFAULT_FLUSH_INTERVAL).to_f
+      flush_interval: ENV.fetch("ONLYLOGS_FLUSH_INTERVAL", DEFAULT_FLUSH_INTERVAL).to_f,
+      max_queue_size: ENV.fetch("ONLYLOGS_MAX_QUEUE_SIZE", DEFAULT_MAX_QUEUE_SIZE).to_i,
+      open_timeout: ENV.fetch("ONLYLOGS_OPEN_TIMEOUT", DEFAULT_OPEN_TIMEOUT).to_f,
+      read_timeout: ENV.fetch("ONLYLOGS_READ_TIMEOUT", DEFAULT_READ_TIMEOUT).to_f,
+      circuit_cooldown: ENV.fetch("ONLYLOGS_CIRCUIT_COOLDOWN", CIRCUIT_COOLDOWN).to_f
     )
       super(local_fallback)
       @drain_url = drain_url
       @batch_size = batch_size
       @flush_interval = flush_interval
+      @max_queue_size = max_queue_size
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @circuit_cooldown = circuit_cooldown
       @queue = Queue.new
       @mutex = Mutex.new
 
+      @consecutive_failures = 0
+      @circuit_open_until = nil
+      @dropped = 0
+
       if @drain_url
         start_sender
       else
@@ -45,7 +73,7 @@ module Onlylogs
       end
 
       formatted = format_message(format_severity(severity), Time.now, progname, message.to_s)
-      @queue << formatted.chomp if formatted && @drain_url
+      enqueue(formatted.chomp) if formatted
       super
     end
 
@@ -62,6 +90,18 @@ module Onlylogs
 
     private
 
+    # Push a line onto the queue unless it is full. Dropping is intentional: blocking the
+    # caller (a request thread) or growing without bound (OOM) are both worse than losing
+    # logs while the drain is unavailable.
+    def enqueue(line)
+      if @queue.size >= @max_queue_size
+        @mutex.synchronize { @dropped += 1 }
+        return
+      end
+
+      @queue << line
+    end
+
     def start_sender
       @running = true
 
@@ -102,20 +142,61 @@ module Onlylogs
 
     def send_batch(lines)
       return if lines.empty?
+      # Drain is known to be down: skip the request entirely so we don't block for the
+      # full read timeout on every batch. The lines are dropped (best-effort logging).
+      return if circuit_open?
 
       uri = URI.parse(@drain_url)
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = (uri.scheme == "https")
-      http.read_timeout = 5
-      http.open_timeout = 2
+      http.read_timeout = @read_timeout
+      http.open_timeout = @open_timeout
 
       request = Net::HTTP::Post.new(uri.path)
       request.body = lines.join("\n")
       request.content_type = "text/plain"
 
       http.start { |h| h.request(request) }
+      record_success
     rescue => e
-      warn "Onlylogs::HttpLogger error: #{e.class}: #{e.message}"
+      record_failure
+      Kernel.warn "Onlylogs::HttpLogger error: #{e.class}: #{e.message}"
+    end
+
+    def circuit_open?
+      @mutex.synchronize { !@circuit_open_until.nil? && Time.now < @circuit_open_until }
+    end
+
+    def record_success
+      @mutex.synchronize do
+        @consecutive_failures = 0
+        @circuit_open_until = nil
+      end
+    end
+
+    def record_failure
+      opened = false
+      dropped = 0
+
+      @mutex.synchronize do
+        @consecutive_failures += 1
+        next if @consecutive_failures < CIRCUIT_FAILURE_THRESHOLD
+
+        # (Re)open the circuit. record_failure only runs on a real send attempt — send_batch
+        # short-circuits while the circuit is open — so reaching here always means the drain
+        # is still down and we should pause again (this is how recovery retries every cooldown).
+        @circuit_open_until = Time.now + @circuit_cooldown
+        opened = true
+        dropped = @dropped
+        @dropped = 0
+      end
+
+      # Warn outside the mutex:
+      # doing it inside the lock would re-enter @mutex through add -> enqueue and raise a recursive-lock error.
+      return unless opened
+
+      suffix = dropped.positive? ? " (#{dropped} log lines dropped)" : ""
+      Kernel.warn "Onlylogs::HttpLogger: drain unavailable, pausing for #{@circuit_cooldown}s#{suffix}"
     end
   end
 end

data/lib/onlylogs/version.rb

@@ -1,3 +1,3 @@
 module Onlylogs
-  VERSION = "0.4.6"
+  VERSION = "0.5.2"
 end

data/lib/onlylogs.rb

@@ -14,6 +14,8 @@ require "onlylogs/http_logger"
 # loader.setup
 
 module Onlylogs
+  class ForbiddenPathError < StandardError; end
+
   if defined?(Importmap)
     mattr_accessor :importmap, default: Importmap::Map.new
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onlylogs
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.2
 platform: ruby
 authors:
 - Alessandro Rodi