qiita_org 0.1.20 → 0.1.25

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/date_rolling_log_file.rb

@@ -0,0 +1,65 @@
+# frozen_string_literals: true
+
+require "date"
+
+module Lumberjack
+  class Device
+    # This log device will append entries to a file and roll the file periodically by date. Files
+    # are rolled at midnight and can be rolled daily, weekly, or monthly. Archive file names will
+    # have the date appended to them in the format ".YYYY-MM-DD" for daily, ".week-of-YYYY-MM-DD" for weekly
+    # and ".YYYY-MM" for monthly. It is not guaranteed that log messages will break exactly on the
+    # roll period as buffered entries will always be written to the same file.
+    class DateRollingLogFile < RollingLogFile
+      # Create a new logging device to the specified file. The period to roll the file is specified
+      # with the :roll option which may contain a value of :daily, :weekly,
+      # or :monthly.
+      def initialize(path, options = {})
+        @manual = options[:manual]
+        @file_date = Date.today
+        if options[:roll]&.to_s&.match(/(daily)|(weekly)|(monthly)/i)
+          @roll_period = $~[0].downcase.to_sym
+          options.delete(:roll)
+        else
+          raise ArgumentError.new("illegal value for :roll (#{options[:roll].inspect})")
+        end
+        super
+      end
+
+      def archive_file_suffix
+        case @roll_period
+        when :weekly
+          @file_date.strftime("week-of-%Y-%m-%d").to_s
+        when :monthly
+          @file_date.strftime("%Y-%m").to_s
+        else
+          @file_date.strftime("%Y-%m-%d").to_s
+        end
+      end
+
+      def roll_file?
+        if @manual
+          true
+        else
+          date = Date.today
+          if date.year > @file_date.year
+            true
+          elsif @roll_period == :daily && date.yday > @file_date.yday
+            true
+          elsif @roll_period == :weekly && date.cweek != @file_date.cweek
+            true
+          elsif @roll_period == :monthly && date.month > @file_date.month
+            true
+          else
+            false
+          end
+        end
+      end
+
+      protected
+
+      def after_roll
+        @file_date = Date.today
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/log_file.rb

@@ -0,0 +1,33 @@
+# frozen_string_literals: true
+
+require "fileutils"
+
+module Lumberjack
+  class Device
+    # This is a logging device that appends log entries to a file.
+    class LogFile < Writer
+      EXTERNAL_ENCODING = "ascii-8bit"
+
+      # The absolute path of the file being logged to.
+      attr_reader :path
+
+      # Create a logger to the file at +path+. Options are passed through to the Writer constructor.
+      def initialize(path, options = {})
+        @path = File.expand_path(path)
+        FileUtils.mkdir_p(File.dirname(@path))
+        super(file_stream, options)
+      end
+
+      def reopen(logdev = nil)
+        close
+        @stream = file_stream
+      end
+
+      private
+
+      def file_stream
+        File.new(@path, "a", encoding: EXTERNAL_ENCODING)
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/multi.rb

@@ -0,0 +1,46 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Device
+    # This is a logging device that forward log entries to multiple other devices.
+    class Multi < Device
+      def initialize(*devices)
+        @devices = devices.flatten
+      end
+
+      def write(entry)
+        @devices.each do |device|
+          device.write(entry)
+        end
+      end
+
+      def flush
+        @devices.each do |device|
+          device.flush
+        end
+      end
+
+      def close
+        @devices.each do |device|
+          device.close
+        end
+      end
+
+      def reopen(logdev = nil)
+        @devices.each do |device|
+          device.reopen(logdev = nil)
+        end
+      end
+
+      def datetime_format
+        @devices.detect(&:datetime_format).datetime_format
+      end
+
+      def datetime_format=(format)
+        @devices.each do |device|
+          device.datetime_format = format
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/null.rb

@@ -0,0 +1,15 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Device
+    # This is a logging device that produces no output. It can be useful in
+    # testing environments when log file output is not useful.
+    class Null < Device
+      def initialize(*args)
+      end
+
+      def write(entry)
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/rolling_log_file.rb

@@ -0,0 +1,145 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Device
+    # This is an abstract class for a device that appends entries to a file and periodically archives
+    # the existing file and starts a one. Subclasses must implement the roll_file? and archive_file_suffix
+    # methods.
+    #
+    # The :keep option can be used to specify a maximum number of rolled log files to keep.
+    # Older files will be deleted based on the time they were created. The default is to keep all files.
+    #
+    # The :min_roll_check option can be used to specify the number of seconds between checking
+    # the file to determine if it needs to be rolled. The default is to check at most once per second.
+    class RollingLogFile < LogFile
+      attr_reader :path
+      attr_accessor :keep
+
+      def initialize(path, options = {})
+        @path = File.expand_path(path)
+        @keep = options[:keep]
+        super(path, options)
+        @file_inode = begin
+                        stream.lstat.ino
+                      rescue
+                        nil
+                      end
+        @@rolls = []
+        @next_stat_check = Time.now.to_f
+        @min_roll_check = (options[:min_roll_check] || 1.0).to_f
+      end
+
+      # Returns a suffix that will be appended to the file name when it is archived.. The suffix should
+      # change after it is time to roll the file. The log file will be renamed when it is rolled.
+      def archive_file_suffix
+        raise NotImplementedError
+      end
+
+      # Return +true+ if the file should be rolled.
+      def roll_file?
+        raise NotImplementedError
+      end
+
+      # Roll the log file by renaming it to the archive file name and then re-opening a stream to the log
+      # file path. Rolling a file is safe in multi-threaded or multi-process environments.
+      def roll_file! #:nodoc:
+        do_once(stream) do
+          archive_file = "#{path}.#{archive_file_suffix}"
+          stream.flush
+          current_inode = begin
+                            File.stat(path).ino
+                          rescue
+                            nil
+                          end
+          if @file_inode && current_inode == @file_inode && !File.exist?(archive_file) && File.exist?(path)
+            begin
+              File.rename(path, archive_file)
+              after_roll
+              cleanup_files!
+            rescue SystemCallError
+              # Ignore rename errors since it indicates the file was already rolled
+            end
+          end
+          reopen_file
+        end
+      rescue => e
+        $stderr.write("Failed to roll file #{path}: #{e.inspect}\n#{e.backtrace.join("\n")}\n")
+      end
+
+      protected
+
+      # This method will be called after a file has been rolled. Subclasses can
+      # implement code to reset the state of the device. This method is thread safe.
+      def after_roll
+      end
+
+      # Handle rolling the file before flushing.
+      def before_flush # :nodoc:
+        if @min_roll_check <= 0.0 || Time.now.to_f >= @next_stat_check
+          @next_stat_check += @min_roll_check
+          path_inode = begin
+                         File.lstat(path).ino
+                       rescue
+                         nil
+                       end
+          if path_inode != @file_inode
+            @file_inode = path_inode
+            reopen_file
+          elsif roll_file?
+            roll_file!
+          end
+        end
+      end
+
+      private
+
+      def reopen_file
+        old_stream = stream
+        new_stream = File.open(path, "a", encoding: EXTERNAL_ENCODING)
+        new_stream.sync = true if buffer_size > 0
+        @file_inode = begin
+                        new_stream.lstat.ino
+                      rescue
+                        nil
+                      end
+        self.stream = new_stream
+        old_stream.close
+      end
+    end
+
+    def cleanup_files!
+      if keep
+        files = Dir.glob("#{path}.*").collect { |f| [f, File.ctime(f)] }.sort { |a, b| b.last <=> a.last }.collect { |a| a.first }
+        if files.size > keep
+          files[keep, files.length].each do |f|
+            File.delete(f)
+          end
+        end
+      end
+    end
+
+    def do_once(file)
+      begin
+        file.flock(File::LOCK_EX)
+      rescue SystemCallError
+        # Most likely can't lock file because the stream is closed
+        return
+      end
+      begin
+        verify = begin
+                   file.lstat
+                 rescue
+                   nil
+                 end
+        # Execute only if the file we locked is still the same one that needed to be rolled
+        yield if verify && verify.ino == @file_inode && verify.size > 0
+      ensure
+        begin
+          file.flock(File::LOCK_UN)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/size_rolling_log_file.rb

@@ -0,0 +1,63 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Device
+    # This is a log device that appends entries to a file and rolls the file when it reaches a specified
+    # size threshold. When a file is rolled, it will have an number extension appended to the file name.
+    # For example, if the log file is named production.log, the first time it is rolled it will be renamed
+    # production.log.1, then production.log.2, etc.
+    class SizeRollingLogFile < RollingLogFile
+      attr_reader :max_size
+
+      # Create an new log device to the specified file. The maximum size of the log file is specified with
+      # the :max_size option. The unit can also be specified: "32K", "100M", "2G" are all valid.
+      def initialize(path, options = {})
+        @manual = options[:manual]
+        @max_size = options[:max_size]
+        if @max_size.is_a?(String)
+          if @max_size =~ /^(\d+(\.\d+)?)([KMG])?$/i
+            @max_size = $~[1].to_f
+            units = $~[3].to_s.upcase
+            case units
+            when "K"
+              @max_size *= 1024
+            when "M"
+              @max_size *= 1024**2
+            when "G"
+              @max_size *= 1024**3
+            end
+            @max_size = @max_size.round
+          else
+            raise ArgumentError.new("illegal value for :max_size (#{@max_size})")
+          end
+        end
+
+        super
+      end
+
+      def archive_file_suffix
+        next_archive_number.to_s
+      end
+
+      def roll_file?
+        @manual || stream.stat.size > @max_size
+      rescue SystemCallError
+        false
+      end
+
+      protected
+
+      # Calculate the next archive file name extension.
+      def next_archive_number # :nodoc:
+        max = 0
+        Dir.glob("#{path}.*").each do |filename|
+          if /\.\d+\z/ =~ filename
+            suffix = filename.split(".").last.to_i
+            max = suffix if suffix > max
+          end
+        end
+        max + 1
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/lumberjack-1.2.8/lib/lumberjack/device/writer.rb

@@ -0,0 +1,182 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Device
+    # This logging device writes log entries as strings to an IO stream. By default, messages will be buffered
+    # and written to the stream in a batch when the buffer is full or when +flush+ is called.
+    #
+    # Subclasses can implement a +before_flush+ method if they have logic to execute before flushing the log.
+    # If it is implemented, it will be called before every flush inside a mutex lock.
+    class Writer < Device
+      DEFAULT_FIRST_LINE_TEMPLATE = "[:time :severity :progname(:pid) #:unit_of_work_id] :message :tags"
+      DEFAULT_ADDITIONAL_LINES_TEMPLATE = "#{Lumberjack::LINE_SEPARATOR}> [#:unit_of_work_id] :message"
+
+      # The size of the internal buffer. Defaults to 32K.
+      attr_reader :buffer_size
+
+      # Internal buffer to batch writes to the stream.
+      class Buffer # :nodoc:
+        attr_reader :size
+
+        def initialize
+          @values = []
+          @size = 0
+        end
+
+        def <<(string)
+          @values << string
+          @size += string.size
+        end
+
+        def empty?
+          @values.empty?
+        end
+
+        def pop!
+          return nil if @values.empty?
+          popped = @values
+          clear
+          popped
+        end
+
+        def clear
+          @values = []
+          @size = 0
+        end
+      end
+
+      # Create a new device to write log entries to a stream. Entries are converted to strings
+      # using a Template. The template can be specified using the :template option. This can
+      # either be a Proc or a string that will compile into a Template object.
+      #
+      # If the template is a Proc, it should accept an LogEntry as its only argument and output a string.
+      #
+      # If the template is a template string, it will be used to create a Template. The
+      # :additional_lines and :time_format options will be passed through to the
+      # Template constuctor.
+      #
+      # The default template is "[:time :severity :progname(:pid) #:unit_of_work_id] :message"
+      # with additional lines formatted as "\n [#:unit_of_work_id] :message". The unit of
+      # work id will only appear if it is present.
+      #
+      # The size of the internal buffer in bytes can be set by providing :buffer_size (defaults to 32K).
+      def initialize(stream, options = {})
+        @lock = Mutex.new
+        @stream = stream
+        @stream.sync = true if @stream.respond_to?(:sync=)
+        @buffer = Buffer.new
+        @buffer_size = (options[:buffer_size] || 0)
+        template = (options[:template] || DEFAULT_FIRST_LINE_TEMPLATE)
+        if template.respond_to?(:call)
+          @template = template
+        else
+          additional_lines = (options[:additional_lines] || DEFAULT_ADDITIONAL_LINES_TEMPLATE)
+          @template = Template.new(template, additional_lines: additional_lines, time_format: options[:time_format])
+        end
+      end
+
+      # Set the buffer size in bytes. The device will only be physically written to when the buffer size
+      # is exceeded.
+      def buffer_size=(value)
+        @buffer_size = value
+        flush
+      end
+
+      # Write an entry to the stream. The entry will be converted into a string using the defined template.
+      def write(entry)
+        string = (entry.is_a?(LogEntry) ? @template.call(entry) : entry)
+        return if string.nil?
+        string = string.strip
+        return if string.length == 0
+
+        unless string.encoding == Encoding::UTF_8
+          string = string.encode("UTF-8", invalid: :replace, undef: :replace)
+        end
+
+        if buffer_size > 1
+          @lock.synchronize do
+            @buffer << string
+          end
+          flush if @buffer.size >= buffer_size
+        else
+          flush if respond_to?(:before_flush, true)
+          write_to_stream(string)
+        end
+      end
+
+      # Close the underlying stream.
+      def close
+        flush
+        stream.close
+      end
+
+      # Flush the underlying stream.
+      def flush
+        lines = nil
+        @lock.synchronize do
+          before_flush if respond_to?(:before_flush, true)
+          lines = @buffer.pop!
+        end
+        write_to_stream(lines) if lines
+      end
+
+      def datetime_format
+        @template.datetime_format if @template.respond_to?(:datetime_format)
+      end
+
+      def datetime_format=(format)
+        if @template.respond_to?(:datetime_format=)
+          @template.datetime_format = format
+        end
+      end
+
+      protected
+
+      # Set the underlying stream.
+      attr_writer :stream
+
+      # Get the underlying stream.
+      attr_reader :stream
+
+      private
+
+      def write_to_stream(lines)
+        return if lines.empty?
+        lines = lines.first if lines.is_a?(Array) && lines.size == 1
+
+        out = nil
+        out = if lines.is_a?(Array)
+          "#{lines.join(Lumberjack::LINE_SEPARATOR)}#{Lumberjack::LINE_SEPARATOR}"
+        else
+          "#{lines}#{Lumberjack::LINE_SEPARATOR}"
+        end
+
+        begin
+          begin
+            stream.write(out)
+          rescue IOError => e
+            # This condition can happen if another thread closed the stream in the `before_flush` call.
+            # Synchronizing will handle the race condition, but since it's an exceptional case we don't
+            # want to lock the thread on every stream write call.
+            @lock.synchronize do
+              if stream.closed?
+                raise e
+              else
+                stream.write(out)
+              end
+            end
+          end
+          begin
+            stream.flush
+          rescue
+            nil
+          end
+        rescue => e
+          $stderr.write("#{e.class.name}: #{e.message}#{" at " + e.backtrace.first if e.backtrace}")
+          $stderr.write(out)
+          $stderr.flush
+        end
+      end
+    end
+  end
+end