rails-pretty-logger 0.1.0 → 0.2.0

data/lib/rails/pretty/logger/active_support_logger.rb

@@ -0,0 +1,107 @@
+require "rails/pretty/logger/console_formatter"
+require "rails/pretty/logger/rails_logger"
+
+module Rails::Pretty::Logger
+
+  class ActiveSupportLogger < RailsLogger
+    include ActiveSupport::LoggerThreadSafeLevel
+    include LoggerSilence
+
+    # Returns true if the logger destination matches one of the sources
+    #
+    #   logger = Logger.new(STDOUT)
+    #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
+    #   # => true
+    def self.logger_outputs_to?(logger, *sources)
+      logdev = logger.instance_variable_get("@logdev")
+      logger_source = logdev.dev if logdev.respond_to?(:dev)
+      sources.any? { |source| source == logger_source }
+    end
+
+    # Broadcasts logs to multiple loggers.
+    def self.broadcast(logger) # :nodoc:
+      Module.new do
+        define_method(:add) do |*args, &block|
+          logger.add(*args, &block)
+          super(*args, &block)
+        end
+
+        define_method(:<<) do |x|
+          logger << x
+          super(x)
+        end
+
+        define_method(:close) do
+          logger.close
+          super()
+        end
+
+        define_method(:progname=) do |name|
+          logger.progname = name
+          super(name)
+        end
+
+        define_method(:formatter=) do |formatter|
+          logger.formatter = formatter
+          super(formatter)
+        end
+
+        define_method(:level=) do |level|
+          logger.level = level
+          super(level)
+        end
+
+        define_method(:local_level=) do |level|
+          logger.local_level = level if logger.respond_to?(:local_level=)
+          super(level) if respond_to?(:local_level=)
+        end
+
+        define_method(:silence) do |level = Logger::ERROR, &block|
+          if logger.respond_to?(:silence)
+            logger.silence(level) do
+              if defined?(super)
+                super(level, &block)
+              else
+                block.call(self)
+              end
+            end
+          else
+            if defined?(super)
+              super(level, &block)
+            else
+              block.call(self)
+            end
+          end
+        end
+      end
+    end
+
+    def initialize(*args)
+      super
+      @formatter = SimpleFormatter.new
+      after_initialize if respond_to? :after_initialize
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      return true if @logdev.nil? || (severity || UNKNOWN) < level
+      super
+    end
+
+    RailsLogger::Severity.constants.each do |severity|
+      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
+      def #{severity.downcase}?                # def debug?
+        RailsLogger::#{severity} >= level           #   DEBUG >= level
+      end                                      # end
+      EOT
+    end
+
+    # Simple formatter which only displays the message.
+    class SimpleFormatter < RailsLogger::Formatter
+      # This method is invoked when a log event occurs
+      def call(severity, timestamp, progname, msg)
+        "#{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+  end
+
+end

data/lib/rails/pretty/logger/config/logger_config.rb

@@ -0,0 +1,17 @@
+require "rails/pretty/logger/console_logger"
+require "rails/pretty/logger/active_support_logger"
+
+
+module Rails
+  module Pretty
+    module Logger
+      module Config
+
+        class LoggerConfig < Rails::Application
+
+        end
+        
+      end
+    end
+  end
+end

data/lib/rails/pretty/logger/console_formatter.rb

@@ -0,0 +1,14 @@
+
+
+module Rails::Pretty::Logger
+  
+  class ConsoleFormatter < ::Logger::Formatter
+    def call(severity, timestamp, _progname, msg)
+
+      formatted_severity = format('%-5s', severity.to_s)
+      formatted_time = timestamp.strftime('%Y-%m-%d %H:%M:%S')
+      "#{formatted_time} || #{formatted_severity}| #{msg}\n"
+    end
+  end
+
+end

data/lib/rails/pretty/logger/console_logger.rb

@@ -0,0 +1,14 @@
+require "rails/pretty/logger/console_formatter"
+require "rails/pretty/logger/active_support_logger"
+
+module Rails::Pretty::Logger
+  
+  class ConsoleLogger < ActiveSupportLogger
+
+    def initialize(*args)
+      super(*args)
+      @formatter = ConsoleFormatter.new
+    end
+  end
+
+end

data/lib/rails/pretty/logger/engine.rb

@@ -4,12 +4,9 @@ module Rails
       class Engine < ::Rails::Engine
         isolate_namespace Rails::Pretty::Logger
         ActiveSupport.on_load(:action_controller) do
-                        include Rails::Pretty::Logger
-                    end
-
-        config.generators do |g|
-          g.test_framework :rspec
+          include Rails::Pretty::Logger
         end
+
       end
     end
   end

data/lib/rails/pretty/logger/rails_logger.rb

@@ -0,0 +1,153 @@
+
+module Rails::Pretty::Logger
+
+  class RailsLogger < ::Logger
+
+    def initialize(logdev, shift_age = 0, shift_size = 1048576, file_count: nil, level: DEBUG,
+      progname: nil, formatter: nil, datetime_format: nil,
+      shift_period_suffix: '%Y%m%d')
+
+      self.level = level
+      self.progname = progname
+      @default_formatter = Formatter.new
+      self.datetime_format = datetime_format
+      self.formatter = formatter
+      @logdev = nil
+      if logdev
+        log_name = "log/" + logdev + ".log"
+        @logdev = LoggerDevice.new(log_name, :shift_age => shift_age,
+          :shift_size => shift_size,
+          :shift_period_suffix => shift_period_suffix, file_count: file_count )
+        end
+      end
+
+      module Period
+        module_function
+
+        SiD = 24 * 60 * 60
+
+        def next_rotate_time(now, shift_age)
+          case shift_age
+          when 'hourly'
+            t = Time.mktime(now.year, now.month, now.mday, now.hour + 1)
+          when 'daily'
+            t = Time.mktime(now.year, now.month, now.mday) + SiD
+          when 'weekly'
+            t = Time.mktime(now.year, now.month, now.mday) + SiD * (7 - now.wday)
+          when 'monthly'
+            t = Time.mktime(now.year, now.month, 1) + SiD * 32
+            return Time.mktime(t.year, t.month, 1)
+          else
+            return now
+          end
+          if (t.hour.nonzero? or t.min.nonzero? or t.sec.nonzero?) && shift_age != 'hourly'
+            hour = t.hour
+            t = Time.mktime(t.year, t.month, t.mday)
+            t += SiD if hour > 12
+
+          elsif shift_age == 'hourly'
+            t = Time.mktime(now.year, now.month, now.mday, now.hour + 1)
+          end
+          t
+        end
+
+        def previous_period_end(now, shift_age)
+          case shift_age
+          when 'hourly'
+            t = Time.mktime(now.year, now.month, now.mday, now.hour - 1)
+          when 'daily'
+            t = Time.mktime(now.year, now.month, now.mday) - SiD / 2
+          when 'weekly'
+            t = Time.mktime(now.year, now.month, now.mday) - (SiD * now.wday + SiD / 2)
+          when 'monthly'
+            t = Time.mktime(now.year, now.month, 1) - SiD / 2
+          else
+            return now
+          end
+
+          if shift_age == 'hourly'
+
+            Time.mktime(t.year, t.month, t.mday, t.hour, t.min, t.sec)
+          else
+            Time.mktime(t.year, t.month, t.mday, 23, 59, 59)
+          end
+
+        end
+      end
+
+      class LoggerDevice < LogDevice
+        include Period
+
+        def initialize(log = nil, shift_age: nil, shift_size: nil, shift_period_suffix: nil, file_count: nil)
+          @dev = @filename = @shift_age = @shift_size = @shift_period_suffix = @file_count = nil
+          mon_initialize
+          set_dev(log)
+          if @filename
+            @shift_age = shift_age || 7
+            @shift_size = shift_size || 1048576
+            @shift_period_suffix = shift_period_suffix || '%Y%m%d'
+            @file_count = file_count || 48
+            unless @shift_age.is_a?(Integer)
+              base_time = @dev.respond_to?(:stat) ? @dev.stat.mtime : Time.now
+              @next_rotate_time = next_rotate_time(base_time, @shift_age)
+            end
+          end
+        end
+
+        def shift_log_period(period_end)
+          suffix = period_end.strftime(@shift_period_suffix)
+
+          suffix_year = period_end.strftime('%Y')
+          suffix_month = period_end.strftime('%m')
+          suffix_day = period_end.strftime('%d')
+
+          if @shift_age == 'hourly'
+            suffix = period_end.strftime('%Y%m%d_%H%M')
+          end
+
+          age_file = "#{@filename}.#{suffix}"
+
+
+          if FileTest.exist?(age_file)
+            # try to avoid filename crash caused by Timestamp change.
+            idx = 0
+            # .99 can be overridden; avoid too much file search with 'loop do'
+            while idx < 100
+              idx += 1
+              age_file = "#{@filename}.#{suffix}.#{idx}"
+              break unless FileTest.exist?(age_file)
+            end
+          end
+
+          #delete old files
+          log_files = Dir[ File.join(Rails.root, 'log', 'hourly') + "/#{suffix_year}/**/*"].reject {|fn| File.directory?(fn) }
+
+          log_files_length = log_files.length
+
+          while (log_files_length > @file_count) do
+            arr = []
+            log_files.each { |x| arr.push(File.ctime(x).to_i) }
+
+            file_index = arr.index(arr.min)
+
+            file_path = log_files[file_index]
+            File.delete(file_path) if File.exist?(file_path)
+
+            log_files = Dir[ File.join(Rails.root, 'log', 'hourly') + "/#{suffix_year}/**/*"].reject {|fn| File.directory?(fn) }
+            log_files_length = log_files.length
+          end
+
+          @dev.close rescue nil
+
+          File.rename("#{@filename}", age_file)
+          old_log_path = Rails.root.join(age_file)
+          new_path = File.join(Rails.root, 'log', 'hourly', suffix_year, suffix_month, suffix_day)
+          FileUtils.mkdir_p new_path
+          FileUtils.mv old_log_path, new_path, :force => true
+          @dev = create_logfile(@filename)
+          return true
+        end
+      end
+
+    end
+  end

data/lib/rails/pretty/logger/version.rb

@@ -1,7 +1,7 @@
 module Rails
   module Pretty
     module Logger
-      VERSION = '0.1.0'
+      VERSION = '0.2.0'
     end
   end
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rails-pretty-logger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Cem
+- Mehmet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-07 00:00:00.000000000 Z
+date: 2019-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -58,9 +59,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
-description: ": Description of Rails::Pretty::Logger."
+description: " With Pretty logger, can check your logs from web page, can also easily
+  check your logs with hourly rotation "
 email:
 - cbaykam@gmail.com
+- mehmetcelik4@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -71,19 +74,31 @@ files:
 - app/assets/config/rails_pretty_logger_manifest.js
 - app/assets/javascripts/rails/pretty/logger/application.js
 - app/assets/javascripts/rails/pretty/logger/dashboards.js
+- app/assets/javascripts/rails/pretty/logger/list.min.js
 - app/assets/stylesheets/rails/pretty/logger/application.css
 - app/assets/stylesheets/rails/pretty/logger/dashboards.css
+- app/assets/stylesheets/rails/pretty/logger/list.css
 - app/controllers/rails/pretty/logger/application_controller.rb
 - app/controllers/rails/pretty/logger/dashboards_controller.rb
+- app/controllers/rails/pretty/logger/hourly_logs_controller.rb
 - app/helpers/rails/pretty/logger/application_helper.rb
 - app/helpers/rails/pretty/logger/dashboards_helper.rb
 - app/models/rails/pretty/logger/application_record.rb
 - app/views/layouts/rails/pretty/logger/application.html.erb
+- app/views/partials/_error_pagination.html.erb
+- app/views/partials/_navbar.html.erb
 - app/views/rails/pretty/logger/dashboards/index.html.erb
 - app/views/rails/pretty/logger/dashboards/logs.html.erb
+- app/views/rails/pretty/logger/hourly_logs/index.html.erb
+- app/views/rails/pretty/logger/hourly_logs/logs.html.erb
 - config/routes.rb
 - lib/rails/pretty/logger.rb
+- lib/rails/pretty/logger/active_support_logger.rb
+- lib/rails/pretty/logger/config/logger_config.rb
+- lib/rails/pretty/logger/console_formatter.rb
+- lib/rails/pretty/logger/console_logger.rb
 - lib/rails/pretty/logger/engine.rb
+- lib/rails/pretty/logger/rails_logger.rb
 - lib/rails/pretty/logger/version.rb
 - lib/tasks/rails/pretty/logger_tasks.rake
 homepage: https://github.com/kekik/rails-pretty-logger
@@ -109,5 +124,6 @@ rubyforge_project:
 rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: ": Summary of Rails::Pretty::Logger."
+summary: Pretty Logger is a logging framework which can be checked from '/your-web-page/rails-pretty-logger/dashboards',
+  can also debug easily with highlight method. And can add Hourly log rotation.
 test_files: []