simple_rotate 1.0.0 → 1.1.0

data/lib/simple_rotate/accesser.rb

@@ -0,0 +1,13 @@
+#--------------------
+# access definitions
+#--------------------
+class SimpleRotate
+    attr_accessor :threshold,
+                  :date_format,
+                  :logging_format,
+                  :rename_format,
+                  :allow_overwrite,
+                  :sleep_time
+
+    attr_reader   :limit
+end

data/lib/simple_rotate/const.rb

@@ -0,0 +1,7 @@
+class SimpleRotate
+    LIBS_NAME   = "simple_rotate"
+    VERSION     = "1.1.0"
+    SUMMARY     = "Simple and safety logger."
+    HOMEPAGE    = "http://khotta.github.io/"
+    DESCRIPTION = "#{SUMMARY} #{HOMEPAGE}"
+end

data/lib/simple_rotate/core.rb

@@ -0,0 +1,306 @@
+# coding: utf-8
+
+# load standard attachments
+require "singleton"
+require "monitor"
+
+# load internal modules
+require_relative "./internal/log_level"
+require_relative "./internal/rotate_term"
+require_relative "./internal/validator"
+require_relative "./internal/error"
+
+# load internal classes
+require_relative "./internal/error"
+require_relative "./internal/process_sync"
+
+# extends myself
+require_relative "./const"
+require_relative "./accesser"
+require_relative "./private"
+
+class SimpleRotate
+    # mix-in
+    include Singleton
+    include MonitorMixin
+    include LogLevel
+    include RotateTerm
+    include Validator
+
+    # return method missing error
+    def method_missing(name, *argv)
+        SimpleRotate::Error.missing(name)
+    end
+
+    # @param string|symbol $file_name
+    # @param string|int    $limit
+    # @param int           $rotation
+    # @return self
+    def init(file_name=File.absolute_path($0+".log"), limit="100M", rotation=0) 
+        @file_name = file_name
+        @limit     = limit
+        @rotation  = rotation
+
+        # load defaults
+        include_defaults
+
+        # validation
+        valid_file_name
+        valid_int("rotation", @rotation)
+
+        # stdout only
+        return self if @only_stdout
+
+        if rotate_by_term?
+            # term rotation
+            set_days_cnt_of_term
+            @limit_term     = @limit
+            @rotate_by_term = true
+
+        else  
+            # file_size rotation
+            @limit_size = trim_byte(@limit)
+            if @limit_size <= 0
+                SimpleRotate::Error.argv("limit", @limit)
+            end
+            @rotate_by_term = false
+        end
+
+        # for process sync
+        @psync = ProcessSync.new(self)
+
+        # open or generate the log file
+        synchronize do
+            @psync.lock
+
+            prepare_logf
+
+            @psync.unlock
+        end
+
+        # if block given, colse IO
+        if defined? yield
+            yield self
+            e
+        end
+
+        return self
+    end
+
+    # log message out to STDOUT when use SimpleRotate#w method
+    def with_stdout
+        @with_stdout = true
+        return nil
+    end
+
+    # enable compress
+    def compress
+        @compress = true
+        use_zlib
+        return nil
+    end
+
+    # define the compression level
+    # this method load 'zlib'
+    # this method enable compress flag
+    # @param int level - 0-9
+    #                    default is 6
+    def compress_level(level)
+        @compress_level = level
+        valid_int("compress_level", @compress_level)
+        compress
+        return nil
+    end
+
+    # @param  string $log message write to log file
+    # @return string
+    def w(log)
+        if @file_name == nil
+            msg = "file_name is Nil Class! Please call #init method"
+            SimpleRotate::Error.throw_error(msg)
+        end
+
+        # don't out log message if Doesn't reach threshold
+        return nil if (!over_threshold?)
+
+        content = get_trimmed_log(log)
+
+        # return and end func, if only_stdout enable
+        if @only_stdout
+            puts content
+            return log
+        end
+
+        # write message to file
+        synchronize do
+            @psync.lock
+
+            sync_inode if !@no_sync_inode
+            @logf.puts(content)
+            @logf.flush if @enable_wflush
+            @logf.fsync if @enable_wflush
+
+            @psync.unlock
+        end
+
+        # dump log message STDOUT, if with_stdout enable
+        puts content if @with_stdout
+
+        # rotate if necessary
+        rotate_if if !@no_wcheck
+
+        return log
+    end
+
+    # disable call File#flush after #w method
+    def enable_wflush
+        @enable_wflush = true
+        return nil
+    end
+
+    # enable call File#flush after #w method
+    def disable_wflush
+        @enable_wflush = false
+        return nil
+    end
+
+    # close file
+    def e
+        return nil if logf_not_usable
+
+        synchronize do
+            @psync.lock
+
+            @logf.close
+
+            @psync.unlock
+        end
+
+        return true
+    end
+
+    # file reopen
+    def reopen
+      return nil if logf_not_usable
+
+      if !file_closed?
+          SimpleRotate::Error.warning("File is already open!")
+          return nil
+      end
+
+      openadd
+      return @logf
+    end
+
+    # force rotation
+    def flush
+        return nil if logf_not_usable
+        return nil if @rotate_by_term
+        rotation(:FLUSH)
+        return true
+    end
+
+    # don't check can to rotate at #w method
+    def no_wcheck
+        @no_wcheck = true
+        return nil;
+    end
+
+    # is log file open?
+    # @return nil|bool
+    def file_closed?
+        return nil if logf_not_usable
+        return @logf.closed?
+    end
+
+    # skip warning message
+    def silence
+        SimpleRotate::Error.silence
+        return nil;
+    end
+
+    # set log level FATAL
+    # @return self
+    def fatal
+        @log_level = 5
+        return self
+    end
+
+    # set log level ERROR
+    # @return self
+    def error
+        @log_level = 4
+        return self
+    end
+
+    # set log level WORN
+    # @return self
+    def warn
+        @log_level = 3
+        return self
+    end
+
+    # set log level INFO
+    # @return self
+    def info
+        @log_level = 2
+        return self
+    end
+
+    # set log level DEBUG
+    # @return self
+    def debug
+        @log_level = 1
+        return self
+    end
+
+    # synchronize processes
+    def psync(sleep_time=0.1)
+        @is_psync      = true
+        @enable_wflush = true
+        @sleep_time    = sleep_time
+
+        @psync = ProcessSync.new(self)
+        return nil
+    end
+
+    # reopen file necessary
+    # @return bool|nil
+    def sync_inode
+        return nil if logf_not_usable
+
+        cnt = 0
+        begin
+            # check i-node number
+            open_inode = @logf.stat.ino
+            logf_inode = File.stat(@file_name).ino
+            raise if open_inode != logf_inode
+
+        rescue
+            cnt += 1
+            sleep(0.1)
+            e
+            openadd
+
+            if cnt <= @sync_inode_limit
+                retry
+            else
+                SimpleRotate::Error.warning(%{inode number didn't not match, tried #{cnt} times!})
+                return false
+            end
+        end
+
+        return true
+    end
+
+    # disable #sync_inode
+    def no_sync_inode
+        @no_sync_inode = true
+        return nil
+    end
+
+    #--------------------
+    # method alias
+    #--------------------
+    alias_method :<<, :w
+end

data/lib/simple_rotate/internal/error.rb

@@ -0,0 +1,56 @@
+class SimpleRotate
+    class Error < RuntimeError
+        msg  = "Aborted the log files rotation,"
+        msg += " an unexpected error has occured."
+        ROTATION_FAILED = msg
+
+        @@silence = false
+
+        # skip warning message
+        def self.silence
+            @@silence = true
+        end
+
+        # argument error
+        def self.argv(param, argv)
+            msg = "'#{param}'='#{argv}' is invalid argument value!"
+            self.throw_error(msg)
+        end
+
+        # method missing
+        def self.missing(name)
+            msg = "undifined method 'SimpleRotate##{name}'"
+            self.throw_error(msg)
+        end
+
+        # file open error
+        def self.open(name)
+            msg = "Couldn't open a '#{name}'"
+            self.throw_error(msg)
+        end
+
+        # load error
+        def self.load(name)
+            msg = "Couldn't load a '#{name}'"
+            self.throw_error(msg)
+        end
+
+        # exist error
+        def self.exist(name, type)
+            msg = "Already exists this #{type} => '#{name}'"
+            self.throw_error(msg)
+        end
+
+        # warning - don't throw error
+        def self.warning(msg)
+            warn "[WARNING] #{msg} - (SimpleRotate::Error)" if !@@silence
+        end
+
+        # @param msg string
+        def self.throw_error(msg)
+            exeption = self.new(msg)
+            warn exeption.message if !@@silence
+            raise SimpleRotate::Error
+        end
+    end
+end

data/lib/simple_rotate/internal/log_level.rb

@@ -0,0 +1,14 @@
+class SimpleRotate
+    module LogLevel
+        LOG_LEVEL_5    = "FATAL"
+        LOG_LEVEL_4    = "ERROR"
+        LOG_LEVEL_3    = "WARN"
+        LOG_LEVEL_2    = "INFO"
+        LOG_LEVEL_1    = "DEBUG"
+        LEVEL_ID_FATAL = 5
+        LEVEL_ID_ERROR = 4
+        LEVEL_ID_WARN  = 3
+        LEVEL_ID_INFO  = 2
+        LEVEL_ID_DEBUG = 1
+    end
+end

data/lib/simple_rotate/internal/process_sync.rb

@@ -0,0 +1,115 @@
+require_relative "./process_sync_mixin"
+
+class SimpleRotate
+    class ProcessSync
+        include ProcessSyncMixin
+
+        ProcessSyncMixin.instance_methods.each do |method_name|
+            method = instance_method(method_name)
+            define_method(method_name) do |*args|
+                # common execution
+                return nil if !@enable
+                # -------------------
+
+                method.bind(self).call(*args)
+            end
+        end
+
+        def initialize(sr)
+            @sr          = sr
+            @enable      = sr.instance_variable_get(:@is_psync)
+            @file_name   = sr.instance_variable_get(:@file_name)
+
+            # #init not called
+            return self if @file_name == nil
+
+            @logf        = sr.instance_variable_get(:@logf)
+            @try_limit   = 3
+            @@tempf_name = File.dirname(@file_name) + File::SEPARATOR + ".SimpleRotate_tempfile_#{File.basename($0)}"
+
+            create_tempfile if @enable && !@@scheduled_del_lockfile
+        end
+
+        # Create the temp file for locking
+        private
+        def create_tempfile
+            if File.exist?(@@tempf_name)
+                open_temp_file
+                return nil
+            end
+
+            begin
+                @@tempf = File.open(@@tempf_name, File::RDWR|File::CREAT|File::EXCL)
+
+            rescue
+                SimpleRotate::Error.warning("Couldn't create temp file => #{@@tempf_name}")
+
+            ensure
+                set_delete_tempfile
+            end
+        end
+
+        private
+        def tempf_exists?
+            return File.exist?(@@tempf_name)
+        end
+
+        # Delete the lock file at the end of the script
+        private
+        def set_delete_tempfile
+            return true if @@scheduled_del_lockfile
+
+            if File.exists?(@@tempf_name)
+                # is it empty?
+                if File.size(@@tempf_name) == 0
+                    delete_at_end
+                else
+                    # it is not empty
+                    msg  = "File is not empty => #{@@tempf_name}#{$-0}"
+                    msg += "Skip to delete temp file!"
+                    SimpleRotate::Error.warning(msg)
+                end
+            end
+            @@scheduled_del_lockfile = true
+        end
+
+        private
+        def delete_at_end
+            at_exit do
+                begin
+                    File.delete(@@tempf_name)
+                rescue
+                    #SimpleRotate::Error.warning("Couldn't delete temp file => #{@@tempf_name}")
+                end
+            end
+        end
+
+        private
+        def reopen_temp_file
+            close_temp_file
+            open_temp_file
+        end
+
+        private
+        def open_temp_file
+            if @@tempf.is_a?(IO) && @@tempf.closed? || !@@tempf.is_a?(IO)
+                begin
+                    @@tempf = File.open(@@tempf_name, File::RDWR|File::CREAT|File::APPEND)
+                rescue
+                    SimpleRotate::Error.warning("Couldn't open temp file => #{@@tempf_name}")
+                end
+            end
+        end
+
+        private
+        def close_temp_file
+            if @@tempf.is_a?(IO) && !@@tempf.closed?
+                begin
+                    @@tempf.close
+                rescue
+                    SimpleRotate::Error.warning("Couldn't close temp file => #{@@tempf_name}")
+                end
+            end
+        end
+    end
+end