diff options
Diffstat (limited to 'vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger')
6 files changed, 400 insertions, 0 deletions
diff --git a/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/errors.rb b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/errors.rb new file mode 100644 index 0000000..8858179 --- /dev/null +++ b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/errors.rb @@ -0,0 +1,9 @@ +# frozen_string_literal: true + +class Logger + # not used after 1.2.7. just for compat. + class Error < RuntimeError # :nodoc: + end + class ShiftingError < Error # :nodoc: + end +end diff --git a/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/formatter.rb b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/formatter.rb new file mode 100644 index 0000000..c634dbf --- /dev/null +++ b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/formatter.rb @@ -0,0 +1,36 @@ +# frozen_string_literal: true + +class Logger + # Default formatter for log messages. + class Formatter + Format = "%.1s, [%s #%d] %5s -- %s: %s\n" + DatetimeFormat = "%Y-%m-%dT%H:%M:%S.%6N" + + attr_accessor :datetime_format + + def initialize + @datetime_format = nil + end + + def call(severity, time, progname, msg) + sprintf(Format, severity, format_datetime(time), Process.pid, severity, progname, msg2str(msg)) + end + + private + + def format_datetime(time) + time.strftime(@datetime_format || DatetimeFormat) + end + + def msg2str(msg) + case msg + when ::String + msg + when ::Exception + "#{ msg.message } (#{ msg.class })\n#{ msg.backtrace.join("\n") if msg.backtrace }" + else + msg.inspect + end + end + end +end diff --git a/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/log_device.rb b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/log_device.rb new file mode 100644 index 0000000..e16f3b7 --- /dev/null +++ b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/log_device.rb @@ -0,0 +1,265 @@ +# frozen_string_literal: true + +require_relative 'period' + +class Logger + # Device used for logging messages. + class LogDevice + include Period + + attr_reader :dev + attr_reader :filename + include MonitorMixin + + def initialize( + log = nil, shift_age: nil, shift_size: nil, shift_period_suffix: nil, + binmode: false, reraise_write_errors: [], skip_header: false + ) + @dev = @filename = @shift_age = @shift_size = @shift_period_suffix = nil + @binmode = binmode + @reraise_write_errors = reraise_write_errors + @skip_header = skip_header + mon_initialize + set_dev(log) + set_file(shift_age, shift_size, shift_period_suffix) if @filename + end + + def write(message) + handle_write_errors("writing") do + synchronize do + if @shift_age and @dev.respond_to?(:stat) + handle_write_errors("shifting") {check_shift_log} + end + handle_write_errors("writing") {@dev.write(message)} + end + end + end + + def close + begin + synchronize do + @dev.close rescue nil + end + rescue Exception + @dev.close rescue nil + end + end + + def reopen(log = nil, shift_age: nil, shift_size: nil, shift_period_suffix: nil, binmode: nil) + # reopen the same filename if no argument, do nothing for IO + log ||= @filename if @filename + @binmode = binmode unless binmode.nil? + if log + synchronize do + if @filename and @dev + @dev.close rescue nil # close only file opened by Logger + @filename = nil + end + set_dev(log) + set_file(shift_age, shift_size, shift_period_suffix) if @filename + end + end + self + end + + private + + # :stopdoc: + + MODE = File::WRONLY | File::APPEND + # TruffleRuby < 24.2 does not have File::SHARE_DELETE + if File.const_defined? :SHARE_DELETE + MODE_TO_OPEN = MODE | File::SHARE_DELETE | File::BINARY + else + MODE_TO_OPEN = MODE | File::BINARY + end + MODE_TO_CREATE = MODE_TO_OPEN | File::CREAT | File::EXCL + + def set_dev(log) + if log.respond_to?(:write) and log.respond_to?(:close) + @dev = log + if log.respond_to?(:path) and path = log.path + if File.exist?(path) + @filename = path + end + end + else + @dev = open_logfile(log) + @filename = log + end + end + + def set_file(shift_age, shift_size, shift_period_suffix) + @shift_age = shift_age || @shift_age || 7 + @shift_size = shift_size || @shift_size || 1048576 + @shift_period_suffix = shift_period_suffix || @shift_period_suffix || '%Y%m%d' + + 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 + + if MODE_TO_OPEN == MODE + def fixup_mode(dev) + dev + end + else + def fixup_mode(dev) + return dev if @binmode + dev.autoclose = false + old_dev = dev + dev = File.new(dev.fileno, mode: MODE, path: dev.path) + old_dev.close + PathAttr.set_path(dev, filename) if defined?(PathAttr) + dev + end + end + + def open_logfile(filename) + begin + dev = File.open(filename, MODE_TO_OPEN) + rescue Errno::ENOENT + create_logfile(filename) + else + dev = fixup_mode(dev) + dev.sync = true + dev.binmode if @binmode + dev + end + end + + def create_logfile(filename) + begin + logdev = File.open(filename, MODE_TO_CREATE) + logdev.flock(File::LOCK_EX) + logdev = fixup_mode(logdev) + logdev.sync = true + logdev.binmode if @binmode + add_log_header(logdev) unless @skip_header + logdev.flock(File::LOCK_UN) + logdev + rescue Errno::EEXIST + # file is created by another process + open_logfile(filename) + end + end + + def handle_write_errors(mesg) + yield + rescue *@reraise_write_errors + raise + rescue + warn("log #{mesg} failed. #{$!}") + end + + def add_log_header(file) + file.write( + "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName] + ) if file.size == 0 + end + + def check_shift_log + if @shift_age.is_a?(Integer) + # Note: always returns false if '0'. + if @filename && (@shift_age > 0) && (@dev.stat.size > @shift_size) + lock_shift_log { shift_log_age } + end + else + now = Time.now + if now >= @next_rotate_time + @next_rotate_time = next_rotate_time(now, @shift_age) + lock_shift_log { shift_log_period(previous_period_end(now, @shift_age)) } + end + end + end + + def lock_shift_log + retry_limit = 8 + retry_sleep = 0.1 + begin + File.open(@filename, MODE_TO_OPEN) do |lock| + lock.flock(File::LOCK_EX) # inter-process locking. will be unlocked at closing file + if File.identical?(@filename, lock) and File.identical?(lock, @dev) + yield # log shifting + else + # log shifted by another process (i-node before locking and i-node after locking are different) + @dev.close rescue nil + @dev = open_logfile(@filename) + end + end + true + rescue Errno::ENOENT + # @filename file would not exist right after #rename and before #create_logfile + if retry_limit <= 0 + warn("log rotation inter-process lock failed. #{$!}") + else + sleep retry_sleep + retry_limit -= 1 + retry_sleep *= 2 + retry + end + end + rescue + warn("log rotation inter-process lock failed. #{$!}") + end + + def shift_log_age + (@shift_age-3).downto(0) do |i| + if FileTest.exist?("#{@filename}.#{i}") + File.rename("#{@filename}.#{i}", "#{@filename}.#{i+1}") + end + end + shift_log_file("#{@filename}.0") + end + + def shift_log_period(period_end) + suffix = period_end.strftime(@shift_period_suffix) + 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 + shift_log_file(age_file) + end + + def shift_log_file(shifted) + stat = @dev.stat + @dev.close rescue nil + File.rename(@filename, shifted) + @dev = create_logfile(@filename) + mode, uid, gid = stat.mode, stat.uid, stat.gid + begin + @dev.chmod(mode) if mode + mode = nil + @dev.chown(uid, gid) + rescue Errno::EPERM + if mode + # failed to chmod, probably nothing can do more. + elsif uid + uid = nil + retry # to change gid only + end + end + return true + end + end +end + +File.open(__FILE__) do |f| + File.new(f.fileno, autoclose: false, path: "").path +rescue IOError + module PathAttr # :nodoc: + attr_reader :path + + def self.set_path(file, path) + file.extend(self).instance_variable_set(:@path, path) + end + end +end diff --git a/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/period.rb b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/period.rb new file mode 100644 index 0000000..a0359de --- /dev/null +++ b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/period.rb @@ -0,0 +1,47 @@ +# frozen_string_literal: true + +class Logger + module Period + module_function + + SiD = 24 * 60 * 60 + + def next_rotate_time(now, shift_age) + case shift_age + when 'daily', :daily + t = Time.mktime(now.year, now.month, now.mday) + SiD + when 'weekly', :weekly + t = Time.mktime(now.year, now.month, now.mday) + SiD * (7 - now.wday) + when 'monthly', :monthly + t = Time.mktime(now.year, now.month, 1) + SiD * 32 + return Time.mktime(t.year, t.month, 1) + when 'now', 'everytime', :now, :everytime + return now + else + raise ArgumentError, "invalid :shift_age #{shift_age.inspect}, should be daily, weekly, monthly, or everytime" + end + if t.hour.nonzero? or t.min.nonzero? or t.sec.nonzero? + hour = t.hour + t = Time.mktime(t.year, t.month, t.mday) + t += SiD if hour > 12 + end + t + end + + def previous_period_end(now, shift_age) + case shift_age + when 'daily', :daily + t = Time.mktime(now.year, now.month, now.mday) - SiD / 2 + when 'weekly', :weekly + t = Time.mktime(now.year, now.month, now.mday) - (SiD * now.wday + SiD / 2) + when 'monthly', :monthly + t = Time.mktime(now.year, now.month, 1) - SiD / 2 + when 'now', 'everytime', :now, :everytime + return now + else + raise ArgumentError, "invalid :shift_age #{shift_age.inspect}, should be daily, weekly, monthly, or everytime" + end + Time.mktime(t.year, t.month, t.mday, 23, 59, 59) + end + end +end diff --git a/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/severity.rb b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/severity.rb new file mode 100644 index 0000000..e96fb0d --- /dev/null +++ b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/severity.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +class Logger + # Logging severity. + module Severity + # Low-level information, mostly for developers. + DEBUG = 0 + # Generic (useful) information about system operation. + INFO = 1 + # A warning. + WARN = 2 + # A handleable error condition. + ERROR = 3 + # An unhandleable error that results in a program crash. + FATAL = 4 + # An unknown message that should always be logged. + UNKNOWN = 5 + + LEVELS = { + "debug" => DEBUG, + "info" => INFO, + "warn" => WARN, + "error" => ERROR, + "fatal" => FATAL, + "unknown" => UNKNOWN, + } + private_constant :LEVELS + + def self.coerce(severity) + if severity.is_a?(Integer) + severity + else + key = severity.to_s.downcase + LEVELS[key] || raise(ArgumentError, "invalid log level: #{severity}") + end + end + end +end diff --git a/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/version.rb b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/version.rb new file mode 100644 index 0000000..0d74bec --- /dev/null +++ b/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/version.rb @@ -0,0 +1,5 @@ +# frozen_string_literal: true + +class Logger + VERSION = "1.7.0" +end |