onlylogs 0.5.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f27d7205791730383562092985355eb068e2568ff617ef7d050966347ebc54df
-  data.tar.gz: 73b44d11e108d5a030134eeba81fe2f40b49442ef7ceba388d16c3348828d7da
+  metadata.gz: 19813b5a5884acae634a3516e4cd23dc67fb5cb359062491a15d331f35de2448
+  data.tar.gz: 158e9b56b481744b67a6d92b0835f1443f769b0f264149fb71fe1b69fc86e250
 SHA512:
-  metadata.gz: 7e9f5954ab6144be0f8886503b6a1bb6ece1926fa01ea3275e2bf6523b68ac9334025c41d5bf6ef5aca79ced1cab5d33d548c3cd1a79ac248b0f8dcb7048ed33
-  data.tar.gz: 986ba53d82a32a5c96ec65a029c543bb0b6123a8e94eb83654bfa6ffbae93327fc8bf295604b0f14faf81042fa358faaa112bac69d54c98b6c254fa258aa193f
+  metadata.gz: 9b2c8cd637017af2c310b06a406d75c0a70659244f6b93dfcb12b0f470337d87c8254e257fa4e4810faea6b12e0f2ad27a60b40d2c3423cc98deb21cf56df39d
+  data.tar.gz: d2b9af11af98db9c2d92142553a1a7cc3eb915ddc398ed91b34a04d201e4cbda3dbc926bd007fef335071cbfc77e91ce22b3ff272c3eb7ffa8b607b032841cc6

data/app/assets/config/onlylogs_manifest.js

@@ -1,2 +1,4 @@
+//= link onlylogs/clusterize.js
+//= link onlylogs/clusterize.css
 //= link_directory ../../javascript/onlylogs .js
 //= link_directory ../../javascript/onlylogs/controllers .js

data/app/assets/javascripts/onlylogs/clusterize.js

@@ -0,0 +1,342 @@
+/* Clusterize.js - v1.0.0 - 2023-01-22
+ http://NeXTs.github.com/Clusterize.js/
+ Copyright (c) 2015 Denis Lukov; Licensed MIT */
+
+;(function(name, definition) {
+    if (typeof module != 'undefined') module.exports = definition();
+    else if (typeof define == 'function' && typeof define.amd == 'object') define(definition);
+    else this[name] = definition();
+}('Clusterize', function() {
+  "use strict"
+
+  // detect ie9 and lower
+  // https://gist.github.com/padolsey/527683#comment-786682
+  var ie = (function(){
+    for( var v = 3,
+             el = document.createElement('b'),
+             all = el.all || [];
+         el.innerHTML = '<!--[if gt IE ' + (++v) + ']><i><![endif]-->',
+         all[0];
+       ){}
+    return v > 4 ? v : document.documentMode;
+  }()),
+  is_mac = navigator.platform.toLowerCase().indexOf('mac') + 1;
+  var Clusterize = function(data) {
+    if( ! (this instanceof Clusterize))
+      return new Clusterize(data);
+    var self = this;
+
+    var defaults = {
+      rows_in_block: 50,
+      blocks_in_cluster: 4,
+      tag: null,
+      show_no_data_row: true,
+      no_data_class: 'clusterize-no-data',
+      no_data_text: 'No data',
+      keep_parity: true,
+      callbacks: {}
+    }
+
+    // public parameters
+    self.options = {};
+    var options = ['rows_in_block', 'blocks_in_cluster', 'show_no_data_row', 'no_data_class', 'no_data_text', 'keep_parity', 'tag', 'callbacks'];
+    for(var i = 0, option; option = options[i]; i++) {
+      self.options[option] = typeof data[option] != 'undefined' && data[option] != null
+        ? data[option]
+        : defaults[option];
+    }
+
+    var elems = ['scroll', 'content'];
+    for(var i = 0, elem; elem = elems[i]; i++) {
+      self[elem + '_elem'] = data[elem + 'Id']
+        ? document.getElementById(data[elem + 'Id'])
+        : data[elem + 'Elem'];
+      if( ! self[elem + '_elem'])
+        throw new Error("Error! Could not find " + elem + " element");
+    }
+
+    // tabindex forces the browser to keep focus on the scrolling list, fixes #11
+    if( ! self.content_elem.hasAttribute('tabindex'))
+      self.content_elem.setAttribute('tabindex', 0);
+
+    // private parameters
+    var rows = isArray(data.rows)
+        ? data.rows
+        : self.fetchMarkup(),
+      cache = {},
+      scroll_top = self.scroll_elem.scrollTop;
+
+    // append initial data
+    self.insertToDOM(rows, cache);
+
+    // restore the scroll position
+    self.scroll_elem.scrollTop = scroll_top;
+
+    // adding scroll handler
+    var last_cluster = false,
+    scroll_debounce = 0,
+    pointer_events_set = false,
+    scrollEv = function() {
+      // fixes scrolling issue on Mac #3
+      if (is_mac) {
+          if( ! pointer_events_set) self.content_elem.style.pointerEvents = 'none';
+          pointer_events_set = true;
+          clearTimeout(scroll_debounce);
+          scroll_debounce = setTimeout(function () {
+              self.content_elem.style.pointerEvents = 'auto';
+              pointer_events_set = false;
+          }, 50);
+      }
+      if (last_cluster != (last_cluster = self.getClusterNum(rows)))
+        self.insertToDOM(rows, cache);
+      if (self.options.callbacks.scrollingProgress)
+        self.options.callbacks.scrollingProgress(self.getScrollProgress());
+    },
+    resize_debounce = 0,
+    resizeEv = function() {
+      clearTimeout(resize_debounce);
+      resize_debounce = setTimeout(self.refresh, 100);
+    }
+    on('scroll', self.scroll_elem, scrollEv);
+    on('resize', window, resizeEv);
+
+    // public methods
+    self.destroy = function(clean) {
+      off('scroll', self.scroll_elem, scrollEv);
+      off('resize', window, resizeEv);
+      self.html((clean ? self.generateEmptyRow() : rows).join(''));
+    }
+    self.refresh = function(force) {
+      if(self.getRowsHeight(rows) || force) self.update(rows);
+    }
+    self.update = function(new_rows) {
+      rows = isArray(new_rows)
+        ? new_rows
+        : [];
+      var scroll_top = self.scroll_elem.scrollTop;
+      // fixes #39
+      if(rows.length * self.options.item_height < scroll_top) {
+        self.scroll_elem.scrollTop = 0;
+        last_cluster = 0;
+      }
+      self.insertToDOM(rows, cache);
+      self.scroll_elem.scrollTop = scroll_top;
+    }
+    self.clear = function() {
+      self.update([]);
+    }
+    self.getRowsAmount = function() {
+      return rows.length;
+    }
+    self.prune = function(count) {
+      if(count <= 0 || rows.length <= count) return;
+      rows = rows.slice(count);
+      var scroll_top = self.scroll_elem.scrollTop;
+      self.insertToDOM(rows, cache);
+      self.scroll_elem.scrollTop = Math.max(0, scroll_top - (count * self.options.item_height));
+    }
+    self.getScrollProgress = function() {
+      return this.options.scroll_top / (rows.length * this.options.item_height) * 100 || 0;
+    }
+
+    var add = function(where, _new_rows) {
+      var new_rows = isArray(_new_rows)
+        ? _new_rows
+        : [];
+      if( ! new_rows.length) return;
+      rows = where == 'append'
+        ? rows.concat(new_rows)
+        : new_rows.concat(rows);
+      self.insertToDOM(rows, cache);
+    }
+    self.append = function(rows) {
+      add('append', rows);
+    }
+    self.prepend = function(rows) {
+      add('prepend', rows);
+    }
+  }
+
+  Clusterize.prototype = {
+    constructor: Clusterize,
+    // fetch existing markup
+    fetchMarkup: function() {
+      var rows = [], rows_nodes = this.getChildNodes(this.content_elem);
+      while (rows_nodes.length) {
+        rows.push(rows_nodes.shift().outerHTML);
+      }
+      return rows;
+    },
+    // get tag name, content tag name, tag height, calc cluster height
+    exploreEnvironment: function(rows, cache) {
+      var opts = this.options;
+      opts.content_tag = this.content_elem.tagName.toLowerCase();
+      if( ! rows.length) return;
+      if(ie && ie <= 9 && ! opts.tag) opts.tag = rows[0].match(/<([^>\s/]*)/)[1].toLowerCase();
+      if(this.content_elem.children.length <= 1) cache.data = this.html(rows[0] + rows[0] + rows[0]);
+      if( ! opts.tag) opts.tag = this.content_elem.children[0].tagName.toLowerCase();
+      this.getRowsHeight(rows);
+    },
+    getRowsHeight: function(rows) {
+      var opts = this.options,
+        prev_item_height = opts.item_height;
+      opts.cluster_height = 0;
+      if( ! rows.length) return;
+      var nodes = this.content_elem.children;
+      if( ! nodes.length) return;
+      var node = nodes[Math.floor(nodes.length / 2)];
+      opts.item_height = node.offsetHeight;
+      // consider table's border-spacing
+      if(opts.tag == 'tr' && getStyle('borderCollapse', this.content_elem) != 'collapse')
+        opts.item_height += parseInt(getStyle('borderSpacing', this.content_elem), 10) || 0;
+      // consider margins (and margins collapsing)
+      if(opts.tag != 'tr') {
+        var marginTop = parseInt(getStyle('marginTop', node), 10) || 0;
+        var marginBottom = parseInt(getStyle('marginBottom', node), 10) || 0;
+        opts.item_height += Math.max(marginTop, marginBottom);
+      }
+      opts.block_height = opts.item_height * opts.rows_in_block;
+      opts.rows_in_cluster = opts.blocks_in_cluster * opts.rows_in_block;
+      opts.cluster_height = opts.blocks_in_cluster * opts.block_height;
+      return prev_item_height != opts.item_height;
+    },
+    // get current cluster number
+    getClusterNum: function (rows) {
+      var opts = this.options;
+      opts.scroll_top = this.scroll_elem.scrollTop;
+      var cluster_divider = opts.cluster_height - opts.block_height;
+      var current_cluster = Math.floor(opts.scroll_top / cluster_divider);
+      var max_cluster = Math.floor((rows.length * opts.item_height) / cluster_divider);
+      return Math.min(current_cluster, max_cluster);
+    },
+    // generate empty row if no data provided
+    generateEmptyRow: function() {
+      var opts = this.options;
+      if( ! opts.tag || ! opts.show_no_data_row) return [];
+      var empty_row = document.createElement(opts.tag),
+        no_data_content = document.createTextNode(opts.no_data_text), td;
+      empty_row.className = opts.no_data_class;
+      if(opts.tag == 'tr') {
+        td = document.createElement('td');
+        // fixes #53
+        td.colSpan = 100;
+        td.appendChild(no_data_content);
+      }
+      empty_row.appendChild(td || no_data_content);
+      return [empty_row.outerHTML];
+    },
+    // generate cluster for current scroll position
+    generate: function (rows) {
+      var opts = this.options,
+        rows_len = rows.length;
+      if (rows_len < opts.rows_in_block) {
+        return {
+          top_offset: 0,
+          bottom_offset: 0,
+          rows_above: 0,
+          rows: rows_len ? rows : this.generateEmptyRow()
+        }
+      }
+      var items_start = Math.max((opts.rows_in_cluster - opts.rows_in_block) * this.getClusterNum(rows), 0),
+        items_end = items_start + opts.rows_in_cluster,
+        top_offset = Math.max(items_start * opts.item_height, 0),
+        bottom_offset = Math.max((rows_len - items_end) * opts.item_height, 0),
+        this_cluster_rows = [],
+        rows_above = items_start;
+      if(top_offset < 1) {
+        rows_above++;
+      }
+      for (var i = items_start; i < items_end; i++) {
+        rows[i] && this_cluster_rows.push(rows[i]);
+      }
+      return {
+        top_offset: top_offset,
+        bottom_offset: bottom_offset,
+        rows_above: rows_above,
+        rows: this_cluster_rows
+      }
+    },
+    renderExtraTag: function(class_name, height) {
+      var tag = document.createElement(this.options.tag),
+        clusterize_prefix = 'clusterize-';
+      tag.className = [clusterize_prefix + 'extra-row', clusterize_prefix + class_name].join(' ');
+      height && (tag.style.height = height + 'px');
+      return tag.outerHTML;
+    },
+    // if necessary verify data changed and insert to DOM
+    insertToDOM: function(rows, cache) {
+      // explore row's height
+      if( ! this.options.cluster_height) {
+        this.exploreEnvironment(rows, cache);
+      }
+      var data = this.generate(rows),
+        this_cluster_rows = data.rows.join(''),
+        this_cluster_content_changed = this.checkChanges('data', this_cluster_rows, cache),
+        top_offset_changed = this.checkChanges('top', data.top_offset, cache),
+        only_bottom_offset_changed = this.checkChanges('bottom', data.bottom_offset, cache),
+        callbacks = this.options.callbacks,
+        layout = [];
+
+      if(this_cluster_content_changed || top_offset_changed) {
+        if(data.top_offset) {
+          this.options.keep_parity && layout.push(this.renderExtraTag('keep-parity'));
+          layout.push(this.renderExtraTag('top-space', data.top_offset));
+        }
+        layout.push(this_cluster_rows);
+        data.bottom_offset && layout.push(this.renderExtraTag('bottom-space', data.bottom_offset));
+        callbacks.clusterWillChange && callbacks.clusterWillChange();
+        this.html(layout.join(''));
+        this.options.content_tag == 'ol' && this.content_elem.setAttribute('start', data.rows_above);
+        this.content_elem.style['counter-increment'] = 'clusterize-counter ' + (data.rows_above-1);
+        callbacks.clusterChanged && callbacks.clusterChanged();
+      } else if(only_bottom_offset_changed) {
+        this.content_elem.lastChild.style.height = data.bottom_offset + 'px';
+      }
+    },
+    // unfortunately ie <= 9 does not allow to use innerHTML for table elements, so make a workaround
+    html: function(data) {
+      var content_elem = this.content_elem;
+      if(ie && ie <= 9 && this.options.tag == 'tr') {
+        var div = document.createElement('div'), last;
+        div.innerHTML = '<table><tbody>' + data + '</tbody></table>';
+        while((last = content_elem.lastChild)) {
+          content_elem.removeChild(last);
+        }
+        var rows_nodes = this.getChildNodes(div.firstChild.firstChild);
+        while (rows_nodes.length) {
+          content_elem.appendChild(rows_nodes.shift());
+        }
+      } else {
+        content_elem.innerHTML = data;
+      }
+    },
+    getChildNodes: function(tag) {
+        var child_nodes = tag.children, nodes = [];
+        for (var i = 0, ii = child_nodes.length; i < ii; i++) {
+            nodes.push(child_nodes[i]);
+        }
+        return nodes;
+    },
+    checkChanges: function(type, value, cache) {
+      var changed = value != cache[type];
+      cache[type] = value;
+      return changed;
+    }
+  }
+
+  // support functions
+  function on(evt, element, fnc) {
+    return element.addEventListener ? element.addEventListener(evt, fnc, false) : element.attachEvent("on" + evt, fnc);
+  }
+  function off(evt, element, fnc) {
+    return element.removeEventListener ? element.removeEventListener(evt, fnc, false) : element.detachEvent("on" + evt, fnc);
+  }
+  function isArray(arr) {
+    return Object.prototype.toString.call(arr) === '[object Array]';
+  }
+  function getStyle(prop, elem) {
+    return window.getComputedStyle ? window.getComputedStyle(elem)[prop] : elem.currentStyle[prop];
+  }
+
+  return Clusterize;
+}));

data/app/assets/stylesheets/onlylogs/clusterize.css

@@ -0,0 +1,35 @@
+/* Clusterize scroll container. Height is controlled by parent container. */
+.clusterize-scroll{
+  overflow: auto;
+}
+
+/**
+ * Avoid vertical margins for extra tags
+ * Necessary for correct calculations when rows have nonzero vertical margins
+ */
+.clusterize-extra-row{
+  margin-top: 0 !important;
+  margin-bottom: 0 !important;
+}
+
+/* By default extra tag .clusterize-keep-parity added to keep parity of rows.
+ * Useful when used :nth-child(even/odd)
+ */
+.clusterize-extra-row.clusterize-keep-parity{
+  display: none;
+}
+
+/* During initialization clusterize adds tabindex to force the browser to keep focus
+ * on the scrolling list, see issue #11
+ * Outline removes default browser's borders for focused elements.
+ */
+.clusterize-content{
+  outline: 0;
+  counter-reset: clusterize-counter;
+}
+
+/* Centering message that appears when no data provided
+ */
+.clusterize-no-data td{
+  text-align: center;
+}

data/app/channels/onlylogs/logs_channel.rb

@@ -3,12 +3,17 @@
 module Onlylogs
   class LogsChannel < ActionCable::Channel::Base
     def subscribed
-      # Rails.logger.info "Client subscribed to Onlylogs::LogsChannel"
-      # Wait for the client to send the cursor position
-      # start_log_watcher will be called from the initialize_watcher method
+      @last_initialize_params = nil
     end
 
     def initialize_watcher(data)
+      # Prevent duplicate calls with identical parameters
+      if @last_initialize_params == data
+        Rails.logger.info "Onlylogs: Ignoring duplicate initialize_watcher call"
+        return
+      end
+
+      @last_initialize_params = data.dup
       cleanup_existing_operations
 
       # Decrypt and verify the file path
@@ -39,19 +44,20 @@ module Onlylogs
         return
       end
 
-      cursor_position = data["cursor_position"] || 0
       filter = data["filter"].presence
       mode = data["mode"] || "live"
       regexp_mode = data["regexp_mode"] == true || data["regexp_mode"] == "true"
-      start_position = data["start_position"]&.to_i || 0
-      end_position = data["end_position"]&.to_i
 
-      if mode == "search"
-        # For search mode, read the entire file with filter and send all matching lines
-        read_entire_file_with_filter(file_path, filter, regexp_mode, start_position, end_position)
+      file_size = ::File.size(file_path)
+      start_position = (data["start_position"]&.to_i || 0).clamp(0, file_size)
+      end_position = data["end_position"]&.to_i&.clamp(0, file_size) if data["end_position"]
+
+      if mode == "static"
+        # Read the entire file with filter and send all matching lines
+        read_static(file_path, filter, regexp_mode, start_position, end_position)
       else
-        # For live mode, start the watcher
-        start_log_watcher(file_path, cursor_position, filter, regexp_mode)
+        # Follow the tail of the file indefinitely
+        start_log_watcher(file_path, filter, regexp_mode)
       end
     end
 
@@ -75,7 +81,11 @@ module Onlylogs
       stop_log_watcher
     end
 
-    def start_log_watcher(file_path, cursor_position, filter = nil, regexp_mode = false)
+    # Bytes from the end of the file to show when starting a live tail without
+    # an explicit cursor (matches the default whole-file live-mode page load).
+    LIVE_TAIL_BYTES = 10_000
+
+    def start_log_watcher(file_path, filter = nil, regexp_mode = false)
       return if @log_watcher_running
 
       @log_watcher_running = true
@@ -84,7 +94,9 @@ module Onlylogs
 
       transmit({action: "message", content: "Reading file. Please wait..."})
 
-      @log_file = Onlylogs::File.new(file_path, last_position: cursor_position)
+      # Start from LIVE_TAIL_BYTES from the end, or from the beginning if file is smaller
+      starting_position = [::File.size(file_path) - LIVE_TAIL_BYTES, 0].max
+      @log_file = Onlylogs::File.new(file_path, last_position: starting_position)
 
       transmit({action: "message", content: ""})
 
@@ -97,10 +109,9 @@ module Onlylogs
             lines_to_send = []
 
             new_lines.each do |log_line|
-              # Filters in live mode are not yet implemented
-              # if @filter.present? && !Onlylogs::Grep.match_line?(log_line.text, @filter, regexp_mode: @regexp_mode)
-              #   next
-              # end
+              if @filter.present? && !Onlylogs::Grep.match_line?(log_line, @filter, regexp_mode: @regexp_mode)
+                next
+              end
 
               lines_to_send << render_log_line(log_line)
             end
@@ -143,34 +154,82 @@ module Onlylogs
       @log_file = nil
     end
 
-    def read_entire_file_with_filter(file_path, filter = nil, regexp_mode = false, start_position = 0, end_position = nil)
+    def read_static(file_path, filter = nil, regexp_mode = false, start_position = 0, end_position = nil)
       @log_watcher_running = true
       @log_file = Onlylogs::File.new(file_path, last_position: 0)
 
-      transmit({action: "message", content: "Searching..."})
+      transmit({action: "message", content: filter.present? ? "Searching..." : "Loading..."})
 
       @batch_sender = BatchSender.new(self)
       @batch_sender.start
 
-      line_count = 0
-
       begin
-        Rails.logger.silence(Logger::ERROR) do
-          @log_file.grep(filter, regexp_mode: regexp_mode, start_position: start_position, end_position: end_position) do |log_line|
-            break if @batch_sender.nil?
-
-            # Add to batch buffer (sender thread will handle sending)
-            @batch_sender.add_line(render_log_line(log_line))
+        last_line = nil
+        last_byte_offset = nil
+        line_count = 0
 
-            line_count += 1
+        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) 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
+
+              # 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
+            end
           end
         end
 
-        # Stop batch sender and flush any remaining lines
+        # Send last line only if no end_position (avoid cut-off line at byte boundary)
+        if last_line && !end_position
+          @batch_sender.add_line(render_log_line(last_line, byte_offset: last_byte_offset, show_expand_button: filter.present?))
+          line_count += 1
+        end
+
         @batch_sender.stop
 
         # Send completion message
-        if line_count >= Onlylogs.max_line_matches
+        if Onlylogs.max_line_matches && line_count >= Onlylogs.max_line_matches
           transmit({action: "finish", content: "Search finished. Search results limit reached."})
         else
           transmit({action: "finish", content: "Search finished."})
@@ -184,8 +243,27 @@ module Onlylogs
       end
     end
 
-    def render_log_line(log_line)
-      "<pre>#{FilePathParser.parse(AnsiColorParser.parse(ERB::Util.html_escape(log_line)))}</pre>"
+    def read_byte_range(file_path, start_position, end_position)
+      file_size = ::File.size(file_path)
+      range_size = (end_position || file_size) - start_position
+
+      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
+      end
+    rescue => e
+      Rails.logger.error "Error reading byte range: #{e.message}"
+    end
+
+    def render_log_line(log_line, byte_offset: nil, show_expand_button: false)
+      parsed = FilePathParser.parse(AnsiColorParser.parse(ERB::Util.html_escape(log_line)))
+
+      {
+        content: parsed,
+        byte_offset: byte_offset,
+        show_expand_button: show_expand_button
+      }
     end
   end
 end

data/app/controllers/onlylogs/logs_controller.rb

@@ -3,15 +3,8 @@
 module Onlylogs
   class LogsController < ApplicationController
     def index
-      @max_lines = (params[:max_lines] || 100).to_i
-
       @available_log_files = Onlylogs.available_log_files
       @log_file_path = selected_log_file_path
-
-      @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