rails-tail-log-monitor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c49d2b0b7fbd62b9ba73a7e390eb7288a4c07ea4709fcd04ccb232fae496b52
+  data.tar.gz: 46e641bafd169e55c7ecaa9eaa5684ef8b1685b94c40e838a86ba95bc61a0076
+SHA512:
+  metadata.gz: c303322df80b932b2b7e8ef05fa8e1eeef498c8df4f867394ecc6015d981a54da552ac8a1218f5845f2ddc4957d98db26c46c6463f9d5846b3faf6e0a204b18c
+  data.tar.gz: 71841858a0fb2e60bc1fd87dd62069766866263c9e701290ffd6c17527afcc94bf924f35f014dd39f255091b2bbf4055b6806e7eed6016286abfc95aeccd458f

data/README.md

@@ -0,0 +1,74 @@
+# Rails Tail Log Monitor
+
+The rails-tail-log-monitor gem simplifies the process of monitoring server logs by displaying the tail of the log file directly in the terminal window alongside the standard Rails server output. With rails-tail-log-monitor, developers can effortlessly keep track of the most recent log entries without the need for manual log file inspection.
+
+![demo](demo.gif)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails-tail-log-monitor', '~> 1.0.0'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install google-translate-free
+
+## Usage
+Make sure your `package.json` has `actioncable`
+```json
+{
+  ...,
+  "@rails/actioncable": "^6.0.0"
+}
+```
+Update `config/cable.yml`
+```yaml
+development:
+  adapter: redis
+  url: <%= "redis://localhost:6379/#{ENV.fetch('REDIS_PORT')}" %>
+  channel_prefix: your_app_development
+```
+Update `routes.rb`
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  ...
+  # example for usage same Sidekiq
+  authenticate :administrator do
+    mount Sidekiq::Web => '/sidekiq'
+    mount LogMonitor::Engine => '/log'
+  end
+end
+```
+Custom setting `config/initializers/rails_tail_log_monitor.rb`
+```ruby
+LogMonitor.configure do |config|
+  config.action_cable_url = "ws://localhost:3000/cable"
+  config.keep_alive_time = 60 # default = 30
+end
+```
+
+After installation and configuration, start your Rails application, open `https://localhost:3000/log` URL, and make a few requests. 
+
+
+## Contributors
+
+- [datpmt](https://github.com/datpmt)
+
+I welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b your-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin your-feature`).
+5.  Create a new pull request.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/app/assets/javascripts/example.js

@@ -0,0 +1,601 @@
+(function() {
+  var context = this;
+
+  (function() {
+    (function() {
+      var slice = [].slice;
+
+      this.ActionCable = {
+        INTERNAL: {
+          "message_types": {
+            "welcome": "welcome",
+            "ping": "ping",
+            "confirmation": "confirm_subscription",
+            "rejection": "reject_subscription"
+          },
+          "default_mount_path": "/cable",
+          "protocols": ["actioncable-v1-json", "actioncable-unsupported"]
+        },
+        WebSocket: window.WebSocket,
+        logger: window.console,
+        createConsumer: function(url) {
+          var ref;
+          if (url == null) {
+            url = (ref = this.getConfig("url")) != null ? ref : this.INTERNAL.default_mount_path;
+          }
+          return new ActionCable.Consumer(this.createWebSocketURL(url));
+        },
+        getConfig: function(name) {
+          var element;
+          element = document.head.querySelector("meta[name='action-cable-" + name + "']");
+          return element != null ? element.getAttribute("content") : void 0;
+        },
+        createWebSocketURL: function(url) {
+          var a;
+          if (url && !/^wss?:/i.test(url)) {
+            a = document.createElement("a");
+            a.href = url;
+            a.href = a.href;
+            a.protocol = a.protocol.replace("http", "ws");
+            return a.href;
+          } else {
+            return url;
+          }
+        },
+        startDebugging: function() {
+          return this.debugging = true;
+        },
+        stopDebugging: function() {
+          return this.debugging = null;
+        },
+        log: function() {
+          var messages, ref;
+          messages = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+          if (this.debugging) {
+            messages.push(Date.now());
+            return (ref = this.logger).log.apply(ref, ["[ActionCable]"].concat(slice.call(messages)));
+          }
+        }
+      };
+
+    }).call(this);
+  }).call(context);
+
+  var ActionCable = context.ActionCable;
+
+  (function() {
+    (function() {
+      var bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+      ActionCable.ConnectionMonitor = (function() {
+        var clamp, now, secondsSince;
+
+        ConnectionMonitor.pollInterval = {
+          min: 3,
+          max: 30
+        };
+
+        ConnectionMonitor.staleThreshold = 6;
+
+        function ConnectionMonitor(connection) {
+          this.connection = connection;
+          this.visibilityDidChange = bind(this.visibilityDidChange, this);
+          this.reconnectAttempts = 0;
+        }
+
+        ConnectionMonitor.prototype.start = function() {
+          if (!this.isRunning()) {
+            this.startedAt = now();
+            delete this.stoppedAt;
+            this.startPolling();
+            document.addEventListener("visibilitychange", this.visibilityDidChange);
+            return ActionCable.log("ConnectionMonitor started. pollInterval = " + (this.getPollInterval()) + " ms");
+          }
+        };
+
+        ConnectionMonitor.prototype.stop = function() {
+          if (this.isRunning()) {
+            this.stoppedAt = now();
+            this.stopPolling();
+            document.removeEventListener("visibilitychange", this.visibilityDidChange);
+            return ActionCable.log("ConnectionMonitor stopped");
+          }
+        };
+
+        ConnectionMonitor.prototype.isRunning = function() {
+          return (this.startedAt != null) && (this.stoppedAt == null);
+        };
+
+        ConnectionMonitor.prototype.recordPing = function() {
+          return this.pingedAt = now();
+        };
+
+        ConnectionMonitor.prototype.recordConnect = function() {
+          this.reconnectAttempts = 0;
+          this.recordPing();
+          delete this.disconnectedAt;
+          return ActionCable.log("ConnectionMonitor recorded connect");
+        };
+
+        ConnectionMonitor.prototype.recordDisconnect = function() {
+          this.disconnectedAt = now();
+          return ActionCable.log("ConnectionMonitor recorded disconnect");
+        };
+
+        ConnectionMonitor.prototype.startPolling = function() {
+          this.stopPolling();
+          return this.poll();
+        };
+
+        ConnectionMonitor.prototype.stopPolling = function() {
+          return clearTimeout(this.pollTimeout);
+        };
+
+        ConnectionMonitor.prototype.poll = function() {
+          return this.pollTimeout = setTimeout((function(_this) {
+            return function() {
+              _this.reconnectIfStale();
+              return _this.poll();
+            };
+          })(this), this.getPollInterval());
+        };
+
+        ConnectionMonitor.prototype.getPollInterval = function() {
+          var interval, max, min, ref;
+          ref = this.constructor.pollInterval, min = ref.min, max = ref.max;
+          interval = 5 * Math.log(this.reconnectAttempts + 1);
+          return Math.round(clamp(interval, min, max) * 1000);
+        };
+
+        ConnectionMonitor.prototype.reconnectIfStale = function() {
+          if (this.connectionIsStale()) {
+            ActionCable.log("ConnectionMonitor detected stale connection. reconnectAttempts = " + this.reconnectAttempts + ", pollInterval = " + (this.getPollInterval()) + " ms, time disconnected = " + (secondsSince(this.disconnectedAt)) + " s, stale threshold = " + this.constructor.staleThreshold + " s");
+            this.reconnectAttempts++;
+            if (this.disconnectedRecently()) {
+              return ActionCable.log("ConnectionMonitor skipping reopening recent disconnect");
+            } else {
+              ActionCable.log("ConnectionMonitor reopening");
+              return this.connection.reopen();
+            }
+          }
+        };
+
+        ConnectionMonitor.prototype.connectionIsStale = function() {
+          var ref;
+          return secondsSince((ref = this.pingedAt) != null ? ref : this.startedAt) > this.constructor.staleThreshold;
+        };
+
+        ConnectionMonitor.prototype.disconnectedRecently = function() {
+          return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+        };
+
+        ConnectionMonitor.prototype.visibilityDidChange = function() {
+          if (document.visibilityState === "visible") {
+            return setTimeout((function(_this) {
+              return function() {
+                if (_this.connectionIsStale() || !_this.connection.isOpen()) {
+                  ActionCable.log("ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = " + document.visibilityState);
+                  return _this.connection.reopen();
+                }
+              };
+            })(this), 200);
+          }
+        };
+
+        now = function() {
+          return new Date().getTime();
+        };
+
+        secondsSince = function(time) {
+          return (now() - time) / 1000;
+        };
+
+        clamp = function(number, min, max) {
+          return Math.max(min, Math.min(max, number));
+        };
+
+        return ConnectionMonitor;
+
+      })();
+
+    }).call(this);
+    (function() {
+      var i, message_types, protocols, ref, supportedProtocols, unsupportedProtocol,
+        slice = [].slice,
+        bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+        indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+      ref = ActionCable.INTERNAL, message_types = ref.message_types, protocols = ref.protocols;
+
+      supportedProtocols = 2 <= protocols.length ? slice.call(protocols, 0, i = protocols.length - 1) : (i = 0, []), unsupportedProtocol = protocols[i++];
+
+      ActionCable.Connection = (function() {
+        Connection.reopenDelay = 500;
+
+        function Connection(consumer) {
+          this.consumer = consumer;
+          this.open = bind(this.open, this);
+          this.subscriptions = this.consumer.subscriptions;
+          this.monitor = new ActionCable.ConnectionMonitor(this);
+          this.disconnected = true;
+        }
+
+        Connection.prototype.send = function(data) {
+          if (this.isOpen()) {
+            this.webSocket.send(JSON.stringify(data));
+            return true;
+          } else {
+            return false;
+          }
+        };
+
+        Connection.prototype.open = function() {
+          if (this.isActive()) {
+            ActionCable.log("Attempted to open WebSocket, but existing socket is " + (this.getState()));
+            return false;
+          } else {
+            ActionCable.log("Opening WebSocket, current state is " + (this.getState()) + ", subprotocols: " + protocols);
+            if (this.webSocket != null) {
+              this.uninstallEventHandlers();
+            }
+            this.webSocket = new ActionCable.WebSocket(this.consumer.url, protocols);
+            this.installEventHandlers();
+            this.monitor.start();
+            return true;
+          }
+        };
+
+        Connection.prototype.close = function(arg) {
+          var allowReconnect, ref1;
+          allowReconnect = (arg != null ? arg : {
+            allowReconnect: true
+          }).allowReconnect;
+          if (!allowReconnect) {
+            this.monitor.stop();
+          }
+          if (this.isActive()) {
+            return (ref1 = this.webSocket) != null ? ref1.close() : void 0;
+          }
+        };
+
+        Connection.prototype.reopen = function() {
+          var error;
+          ActionCable.log("Reopening WebSocket, current state is " + (this.getState()));
+          if (this.isActive()) {
+            try {
+              return this.close();
+            } catch (error1) {
+              error = error1;
+              return ActionCable.log("Failed to reopen WebSocket", error);
+            } finally {
+              ActionCable.log("Reopening WebSocket in " + this.constructor.reopenDelay + "ms");
+              setTimeout(this.open, this.constructor.reopenDelay);
+            }
+          } else {
+            return this.open();
+          }
+        };
+
+        Connection.prototype.getProtocol = function() {
+          var ref1;
+          return (ref1 = this.webSocket) != null ? ref1.protocol : void 0;
+        };
+
+        Connection.prototype.isOpen = function() {
+          return this.isState("open");
+        };
+
+        Connection.prototype.isActive = function() {
+          return this.isState("open", "connecting");
+        };
+
+        Connection.prototype.isProtocolSupported = function() {
+          var ref1;
+          return ref1 = this.getProtocol(), indexOf.call(supportedProtocols, ref1) >= 0;
+        };
+
+        Connection.prototype.isState = function() {
+          var ref1, states;
+          states = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+          return ref1 = this.getState(), indexOf.call(states, ref1) >= 0;
+        };
+
+        Connection.prototype.getState = function() {
+          var ref1, state, value;
+          for (state in WebSocket) {
+            value = WebSocket[state];
+            if (value === ((ref1 = this.webSocket) != null ? ref1.readyState : void 0)) {
+              return state.toLowerCase();
+            }
+          }
+          return null;
+        };
+
+        Connection.prototype.installEventHandlers = function() {
+          var eventName, handler;
+          for (eventName in this.events) {
+            handler = this.events[eventName].bind(this);
+            this.webSocket["on" + eventName] = handler;
+          }
+        };
+
+        Connection.prototype.uninstallEventHandlers = function() {
+          var eventName;
+          for (eventName in this.events) {
+            this.webSocket["on" + eventName] = function() {};
+          }
+        };
+
+        Connection.prototype.events = {
+          message: function(event) {
+            var identifier, message, ref1, type;
+            if (!this.isProtocolSupported()) {
+              return;
+            }
+            ref1 = JSON.parse(event.data), identifier = ref1.identifier, message = ref1.message, type = ref1.type;
+            switch (type) {
+              case message_types.welcome:
+                this.monitor.recordConnect();
+                return this.subscriptions.reload();
+              case message_types.ping:
+                return this.monitor.recordPing();
+              case message_types.confirmation:
+                return this.subscriptions.notify(identifier, "connected");
+              case message_types.rejection:
+                return this.subscriptions.reject(identifier);
+              default:
+                return this.subscriptions.notify(identifier, "received", message);
+            }
+          },
+          open: function() {
+            ActionCable.log("WebSocket onopen event, using '" + (this.getProtocol()) + "' subprotocol");
+            this.disconnected = false;
+            if (!this.isProtocolSupported()) {
+              ActionCable.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+              return this.close({
+                allowReconnect: false
+              });
+            }
+          },
+          close: function(event) {
+            ActionCable.log("WebSocket onclose event");
+            if (this.disconnected) {
+              return;
+            }
+            this.disconnected = true;
+            this.monitor.recordDisconnect();
+            return this.subscriptions.notifyAll("disconnected", {
+              willAttemptReconnect: this.monitor.isRunning()
+            });
+          },
+          error: function() {
+            return ActionCable.log("WebSocket onerror event");
+          }
+        };
+
+        return Connection;
+
+      })();
+
+    }).call(this);
+    (function() {
+      var slice = [].slice;
+
+      ActionCable.Subscriptions = (function() {
+        function Subscriptions(consumer) {
+          this.consumer = consumer;
+          this.subscriptions = [];
+        }
+
+        Subscriptions.prototype.create = function(channelName, mixin) {
+          var channel, params, subscription;
+          channel = channelName;
+          params = typeof channel === "object" ? channel : {
+            channel: channel
+          };
+          subscription = new ActionCable.Subscription(this.consumer, params, mixin);
+          return this.add(subscription);
+        };
+
+        Subscriptions.prototype.add = function(subscription) {
+          this.subscriptions.push(subscription);
+          this.consumer.ensureActiveConnection();
+          this.notify(subscription, "initialized");
+          this.sendCommand(subscription, "subscribe");
+          return subscription;
+        };
+
+        Subscriptions.prototype.remove = function(subscription) {
+          this.forget(subscription);
+          if (!this.findAll(subscription.identifier).length) {
+            this.sendCommand(subscription, "unsubscribe");
+          }
+          return subscription;
+        };
+
+        Subscriptions.prototype.reject = function(identifier) {
+          var i, len, ref, results, subscription;
+          ref = this.findAll(identifier);
+          results = [];
+          for (i = 0, len = ref.length; i < len; i++) {
+            subscription = ref[i];
+            this.forget(subscription);
+            this.notify(subscription, "rejected");
+            results.push(subscription);
+          }
+          return results;
+        };
+
+        Subscriptions.prototype.forget = function(subscription) {
+          var s;
+          this.subscriptions = (function() {
+            var i, len, ref, results;
+            ref = this.subscriptions;
+            results = [];
+            for (i = 0, len = ref.length; i < len; i++) {
+              s = ref[i];
+              if (s !== subscription) {
+                results.push(s);
+              }
+            }
+            return results;
+          }).call(this);
+          return subscription;
+        };
+
+        Subscriptions.prototype.findAll = function(identifier) {
+          var i, len, ref, results, s;
+          ref = this.subscriptions;
+          results = [];
+          for (i = 0, len = ref.length; i < len; i++) {
+            s = ref[i];
+            if (s.identifier === identifier) {
+              results.push(s);
+            }
+          }
+          return results;
+        };
+
+        Subscriptions.prototype.reload = function() {
+          var i, len, ref, results, subscription;
+          ref = this.subscriptions;
+          results = [];
+          for (i = 0, len = ref.length; i < len; i++) {
+            subscription = ref[i];
+            results.push(this.sendCommand(subscription, "subscribe"));
+          }
+          return results;
+        };
+
+        Subscriptions.prototype.notifyAll = function() {
+          var args, callbackName, i, len, ref, results, subscription;
+          callbackName = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+          ref = this.subscriptions;
+          results = [];
+          for (i = 0, len = ref.length; i < len; i++) {
+            subscription = ref[i];
+            results.push(this.notify.apply(this, [subscription, callbackName].concat(slice.call(args))));
+          }
+          return results;
+        };
+
+        Subscriptions.prototype.notify = function() {
+          var args, callbackName, i, len, results, subscription, subscriptions;
+          subscription = arguments[0], callbackName = arguments[1], args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
+          if (typeof subscription === "string") {
+            subscriptions = this.findAll(subscription);
+          } else {
+            subscriptions = [subscription];
+          }
+          results = [];
+          for (i = 0, len = subscriptions.length; i < len; i++) {
+            subscription = subscriptions[i];
+            results.push(typeof subscription[callbackName] === "function" ? subscription[callbackName].apply(subscription, args) : void 0);
+          }
+          return results;
+        };
+
+        Subscriptions.prototype.sendCommand = function(subscription, command) {
+          var identifier;
+          identifier = subscription.identifier;
+          return this.consumer.send({
+            command: command,
+            identifier: identifier
+          });
+        };
+
+        return Subscriptions;
+
+      })();
+
+    }).call(this);
+    (function() {
+      ActionCable.Subscription = (function() {
+        var extend;
+
+        function Subscription(consumer, params, mixin) {
+          this.consumer = consumer;
+          if (params == null) {
+            params = {};
+          }
+          this.identifier = JSON.stringify(params);
+          extend(this, mixin);
+        }
+
+        Subscription.prototype.perform = function(action, data) {
+          if (data == null) {
+            data = {};
+          }
+          data.action = action;
+          return this.send(data);
+        };
+
+        Subscription.prototype.send = function(data) {
+          return this.consumer.send({
+            command: "message",
+            identifier: this.identifier,
+            data: JSON.stringify(data)
+          });
+        };
+
+        Subscription.prototype.unsubscribe = function() {
+          return this.consumer.subscriptions.remove(this);
+        };
+
+        extend = function(object, properties) {
+          var key, value;
+          if (properties != null) {
+            for (key in properties) {
+              value = properties[key];
+              object[key] = value;
+            }
+          }
+          return object;
+        };
+
+        return Subscription;
+
+      })();
+
+    }).call(this);
+    (function() {
+      ActionCable.Consumer = (function() {
+        function Consumer(url) {
+          this.url = url;
+          this.subscriptions = new ActionCable.Subscriptions(this);
+          this.connection = new ActionCable.Connection(this);
+        }
+
+        Consumer.prototype.send = function(data) {
+          return this.connection.send(data);
+        };
+
+        Consumer.prototype.connect = function() {
+          return this.connection.open();
+        };
+
+        Consumer.prototype.disconnect = function() {
+          return this.connection.close({
+            allowReconnect: false
+          });
+        };
+
+        Consumer.prototype.ensureActiveConnection = function() {
+          if (!this.connection.isActive()) {
+            return this.connection.open();
+          }
+        };
+
+        return Consumer;
+
+      })();
+
+    }).call(this);
+  }).call(this);
+
+  if (typeof module === "object" && module.exports) {
+    module.exports = ActionCable;
+  } else if (typeof define === "function" && define.amd) {
+    define(ActionCable);
+  }
+}).call(this);

data/app/channels/application_cable/channel.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/app/channels/application_cable/connection.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/app/channels/log_channel.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class LogChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from 'log_channel'
+  end
+
+  def keep_alive
+    $monitoring_keep_alive = Time.zone.now.to_i
+  end
+end

data/app/controllers/log_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rails-tail-log-monitor'
+class LogController < ::ApplicationController
+  layout 'log'
+  def index
+    LogMonitor::LogMonitorService.start_monitoring
+  end
+end

data/app/views/layouts/log.html.erb

@@ -0,0 +1,40 @@
+<style>
+  html, body {
+    margin: 0 !important;
+    padding: 0 !important;
+  }
+
+  #log-title {
+    right: 40px !important;
+    font-weight: 900 !important;
+    font-size: 24px !important;
+    color: #FF0188 !important;
+    position: fixed !important;
+    font-family: monospace;
+  }
+
+  #log-content {
+    background-color: black;
+    color: floralwhite;
+    height: 100vh;
+    overflow-y: scroll;
+    white-space: pre-wrap;
+    padding: 20px;
+    font-family: monospace;
+    word-break: break-all;
+    box-sizing: border-box;
+    font-size: 14px;
+  }
+</style>
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>Rails Tail Log</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+    <%= javascript_include_tag "example" %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/app/views/log/index.html.erb

@@ -0,0 +1,31 @@
+<div id="log-content"><h1 id="log-title">Log Tail Monitor</h1></div>
+<script>
+  document.addEventListener("DOMContentLoaded", function(event) {
+    const consumer = ActionCable.createConsumer();
+
+    const subscription = consumer.subscriptions.create({ channel: "LogChannel" }, {
+      connected() {
+        console.log('Connected.');
+      },
+      disconnected() {
+        console.log('Disconnected.');
+      },
+      received(data) {
+        const logContent = document.getElementById('log-content');
+        data.log_entries.forEach(log => {
+          const logElement = document.createElement('div');
+          logElement.innerHTML = log;
+          logContent.appendChild(logElement);
+        });
+        logContent.scrollTop = logContent.scrollHeight;
+      }
+    });
+
+    function recursiveFetch() {
+      subscription.perform('keep_alive');
+      setTimeout(recursiveFetch, 1000);
+    }
+
+    recursiveFetch();
+  });
+</script>

data/lib/rails-tail-log-monitor/engine.rb

@@ -0,0 +1,16 @@
+# lib/rails-tail-log-monitor/engine.rb
+module LogMonitor
+  class Engine < ::Rails::Engine
+    isolate_namespace LogMonitor
+
+    initializer 'log_monitor.assets.precompile' do |app|
+      app.config.assets.precompile += %w[example.js]
+    end
+
+    initializer 'log_monitor.routes' do |app|
+      app.routes.append do
+        get '/log', to: 'log#index'
+      end
+    end
+  end
+end

data/lib/rails-tail-log-monitor.rb

@@ -0,0 +1,125 @@
+# lib/rails-tail-log-monitor.rb
+
+require 'rails-tail-log-monitor/engine'
+
+module LogMonitor
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  class Configuration
+    DEFAULT_ACTION_CABLE_URL = 'ws://localhost:3000/cable'.freeze
+    DEFAULT_KEEP_ALIVE_TIME = 30
+
+    class << self
+      def action_cable_url
+        configuration.action_cable_url
+      end
+
+      def keep_alive_time
+        configuration.keep_alive_time
+      end
+    end
+
+    attr_accessor :action_cable_url, :keep_alive_time
+
+    def initialize
+      @action_cable_url = DEFAULT_ACTION_CABLE_URL
+      @keep_alive_time = DEFAULT_KEEP_ALIVE_TIME
+    end
+
+    def keep_alive_time=(time)
+      @keep_alive_time = [time.to_i, DEFAULT_KEEP_ALIVE_TIME].max
+    end
+  end
+
+  class Railtie < Rails::Railtie
+    config.after_initialize do
+      ActionCable.server.config.logger = Logger.new(nil)
+      ActionCable.server.config.url = LogMonitor.configuration.action_cable_url
+    end
+  end
+
+  class LogMonitorService
+    ANSI_TO_HTML = {
+      '30' => 'black',
+      '31' => 'red',
+      '32' => 'green',
+      '33' => 'yellow',
+      '34' => 'blue',
+      '35' => 'magenta',
+      '36' => 'cyan',
+      '37' => 'white',
+      '90' => 'darkgrey',
+      '91' => 'lightred',
+      '92' => 'lightgreen',
+      '93' => 'lightyellow',
+      '94' => 'lightblue',
+      '95' => 'lightmagenta',
+      '96' => 'lightcyan',
+      '97' => 'lightgrey'
+    }.freeze
+
+    def self.start_monitoring
+      $monitoring_keep_alive = Time.zone.now.to_i
+      $monitoring_thread ||= Thread.new { monitor_log }
+    end
+
+    def self.stop_monitoring
+      $monitoring_thread&.kill
+      $monitoring_thread&.join
+      $monitoring_thread = nil
+    end
+
+    def self.monitor_log
+      log_file = Rails.root.join('log', "#{Rails.env}.log")
+      last_position = File.size(log_file)
+
+      begin
+        loop do
+          sleep 0.3
+          if Time.zone.now.to_i - $monitoring_keep_alive > LogMonitor.configuration.keep_alive_time
+            stop_monitoring
+            break
+          else
+            new_log_entries = File.open(log_file, 'r') do |file|
+              file.seek(last_position)
+              file.read
+            end.split("\n", -1)
+            if new_log_entries.present?
+              new_log_entries = new_log_entries[0..-2] if new_log_entries.last.empty?
+              ActionCable.server.broadcast(
+                'log_channel', { log_entries: new_log_entries.map { |log| ansi_to_html(log) } }
+              )
+            end
+
+            last_position = File.size(log_file)
+          end
+        end
+      rescue StandardError => e
+        Rails.logger.error "Error in LogMonitorService: #{e.message}"
+      end
+    end
+
+    def self.ansi_to_html(log)
+      return '<br>' if log.blank?
+
+      html_text = log.dup
+      html_text = html_text.gsub('<', '&lt;').gsub('>', '&gt;')
+      ANSI_TO_HTML.each_key do |code|
+        html_text.gsub!(/\e\[#{code}m/, "<span style='color: #{ANSI_TO_HTML[code]};'>")
+      end
+      html_text.gsub!(/\e\[0m/, '</span>')
+      html_text.gsub!(/\e\[1m/, "<span style='font-weight: bold;'>")
+      html_text
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: rails-tail-log-monitor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- datpmt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+description: The rails-tail-log-monitor gem simplifies the process of monitoring server
+  logs by displaying the tail of the log file directly in the terminal window alongside
+  the standard Rails server output. With rails-tail-log-monitor, developers can effortlessly
+  keep track of the most recent log entries without the need for manual log file inspection.
+email: datpmt.2k@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- app/assets/javascripts/example.js
+- app/channels/application_cable/channel.rb
+- app/channels/application_cable/connection.rb
+- app/channels/log_channel.rb
+- app/controllers/log_controller.rb
+- app/views/layouts/log.html.erb
+- app/views/log/index.html.erb
+- lib/rails-tail-log-monitor.rb
+- lib/rails-tail-log-monitor/engine.rb
+homepage: https://rubygems.org/gems/rails-tail-log-monitor
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/datpmt/rails-tail-log-monitor
+  changelog_uri: https://github.com/datpmt/rails-tail-log-monitor/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: 'Purpose: Displays the tail of the server log in the terminal alongside the
+  Rails server output.'
+test_files: []