From adaceea16772289945e38cabbed4b26dc68854ea Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 4 Sep 2024 16:53:28 +0000 Subject: [PATCH 1/4] build(deps-dev): bump logger from 1.6.0 to 1.6.1 in /Library/Homebrew Bumps [logger](https://github.com/ruby/logger) from 1.6.0 to 1.6.1. - [Release notes](https://github.com/ruby/logger/releases) - [Commits](https://github.com/ruby/logger/compare/v1.6.0...v1.6.1) --- updated-dependencies: - dependency-name: logger dependency-type: indirect update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- Library/Homebrew/Gemfile.lock | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index d2cbebb590..45cb5a20e5 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -25,7 +25,7 @@ GEM kramdown (2.4.0) rexml language_server-protocol (3.17.0.3) - logger (1.6.0) + logger (1.6.1) method_source (1.1.0) minitest (5.25.1) netrc (0.11.0) @@ -156,7 +156,6 @@ GEM PLATFORMS aarch64-linux - arm-linux arm64-darwin x86_64-darwin x86_64-linux From 3d815d0c2f83390b5a2e10d46dc46348edf4c2a1 Mon Sep 17 00:00:00 2001 From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com> Date: Wed, 4 Sep 2024 16:56:33 +0000 Subject: [PATCH 2/4] brew vendor-gems: commit updates. --- Library/Homebrew/Gemfile.lock | 1 + .../Homebrew/vendor/bundle/bundler/setup.rb | 2 +- .../3.3.0/gems/logger-1.6.1/lib/logger.rb | 757 ++++++++++++++++++ .../gems/logger-1.6.1/lib/logger/errors.rb | 9 + .../gems/logger-1.6.1/lib/logger/formatter.rb | 36 + .../logger-1.6.1/lib/logger/log_device.rb | 214 +++++ .../gems/logger-1.6.1/lib/logger/period.rb | 47 ++ .../gems/logger-1.6.1/lib/logger/severity.rb | 38 + .../gems/logger-1.6.1/lib/logger/version.rb | 5 + 9 files changed, 1108 insertions(+), 1 deletion(-) create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb create mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock index 45cb5a20e5..4edb360252 100644 --- a/Library/Homebrew/Gemfile.lock +++ b/Library/Homebrew/Gemfile.lock @@ -156,6 +156,7 @@ GEM PLATFORMS aarch64-linux + arm-linux arm64-darwin x86_64-darwin x86_64-linux diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb index a6802ba7a8..50a808ae65 100644 --- a/Library/Homebrew/vendor/bundle/bundler/setup.rb +++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb @@ -58,7 +58,7 @@ $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rexml-3.3.6/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/kramdown-2.4.0/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/language_server-protocol-3.17.0.3/lib") -$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/logger-1.6.0/lib") +$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/logger-1.6.1/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/method_source-1.1.0/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/minitest-5.25.1/lib") $:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/netrc-0.11.0/lib") diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb new file mode 100644 index 0000000000..47352097fd --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb @@ -0,0 +1,757 @@ +# frozen_string_literal: true +# logger.rb - simple logging utility +# Copyright (C) 2000-2003, 2005, 2008, 2011 NAKAMURA, Hiroshi . +# +# Documentation:: NAKAMURA, Hiroshi and Gavin Sinclair +# License:: +# You can redistribute it and/or modify it under the same terms of Ruby's +# license; either the dual license version in 2003, or any later version. +# Revision:: $Id$ +# +# A simple system for logging messages. See Logger for more documentation. + +require 'fiber' +require 'monitor' +require 'rbconfig' + +require_relative 'logger/version' +require_relative 'logger/formatter' +require_relative 'logger/log_device' +require_relative 'logger/severity' +require_relative 'logger/errors' + +# \Class \Logger provides a simple but sophisticated logging utility that +# you can use to create one or more +# {event logs}[https://en.wikipedia.org/wiki/Logging_(software)#Event_logs] +# for your program. +# Each such log contains a chronological sequence of entries +# that provides a record of the program's activities. +# +# == About the Examples +# +# All examples on this page assume that \Logger has been required: +# +# require 'logger' +# +# == Synopsis +# +# Create a log with Logger.new: +# +# # Single log file. +# logger = Logger.new('t.log') +# # Size-based rotated logging: 3 10-megabyte files. +# logger = Logger.new('t.log', 3, 10485760) +# # Period-based rotated logging: daily (also allowed: 'weekly', 'monthly'). +# logger = Logger.new('t.log', 'daily') +# # Log to an IO stream. +# logger = Logger.new($stdout) +# +# Add entries (level, message) with Logger#add: +# +# logger.add(Logger::DEBUG, 'Maximal debugging info') +# logger.add(Logger::INFO, 'Non-error information') +# logger.add(Logger::WARN, 'Non-error warning') +# logger.add(Logger::ERROR, 'Non-fatal error') +# logger.add(Logger::FATAL, 'Fatal error') +# logger.add(Logger::UNKNOWN, 'Most severe') +# +# Close the log with Logger#close: +# +# logger.close +# +# == Entries +# +# You can add entries with method Logger#add: +# +# logger.add(Logger::DEBUG, 'Maximal debugging info') +# logger.add(Logger::INFO, 'Non-error information') +# logger.add(Logger::WARN, 'Non-error warning') +# logger.add(Logger::ERROR, 'Non-fatal error') +# logger.add(Logger::FATAL, 'Fatal error') +# logger.add(Logger::UNKNOWN, 'Most severe') +# +# These shorthand methods also add entries: +# +# logger.debug('Maximal debugging info') +# logger.info('Non-error information') +# logger.warn('Non-error warning') +# logger.error('Non-fatal error') +# logger.fatal('Fatal error') +# logger.unknown('Most severe') +# +# When you call any of these methods, +# the entry may or may not be written to the log, +# depending on the entry's severity and on the log level; +# see {Log Level}[rdoc-ref:Logger@Log+Level] +# +# An entry always has: +# +# - A severity (the required argument to #add). +# - An automatically created timestamp. +# +# And may also have: +# +# - A message. +# - A program name. +# +# Example: +# +# logger = Logger.new($stdout) +# logger.add(Logger::INFO, 'My message.', 'mung') +# # => I, [2022-05-07T17:21:46.536234 #20536] INFO -- mung: My message. +# +# The default format for an entry is: +# +# "%s, [%s #%d] %5s -- %s: %s\n" +# +# where the values to be formatted are: +# +# - \Severity (one letter). +# - Timestamp. +# - Process id. +# - \Severity (word). +# - Program name. +# - Message. +# +# You can use a different entry format by: +# +# - Setting a custom format proc (affects following entries); +# see {formatter=}[Logger.html#attribute-i-formatter]. +# - Calling any of the methods above with a block +# (affects only the one entry). +# Doing so can have two benefits: +# +# - Context: the block can evaluate the entire program context +# and create a context-dependent message. +# - Performance: the block is not evaluated unless the log level +# permits the entry actually to be written: +# +# logger.error { my_slow_message_generator } +# +# Contrast this with the string form, where the string is +# always evaluated, regardless of the log level: +# +# logger.error("#{my_slow_message_generator}") +# +# === \Severity +# +# The severity of a log entry has two effects: +# +# - Determines whether the entry is selected for inclusion in the log; +# see {Log Level}[rdoc-ref:Logger@Log+Level]. +# - Indicates to any log reader (whether a person or a program) +# the relative importance of the entry. +# +# === Timestamp +# +# The timestamp for a log entry is generated automatically +# when the entry is created. +# +# The logged timestamp is formatted by method +# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime] +# using this format string: +# +# '%Y-%m-%dT%H:%M:%S.%6N' +# +# Example: +# +# logger = Logger.new($stdout) +# logger.add(Logger::INFO) +# # => I, [2022-05-07T17:04:32.318331 #20536] INFO -- : nil +# +# You can set a different format using method #datetime_format=. +# +# === Message +# +# The message is an optional argument to an entry method: +# +# logger = Logger.new($stdout) +# logger.add(Logger::INFO, 'My message') +# # => I, [2022-05-07T18:15:37.647581 #20536] INFO -- : My message +# +# For the default entry formatter, Logger::Formatter, +# the message object may be: +# +# - A string: used as-is. +# - An Exception: message.message is used. +# - Anything else: message.inspect is used. +# +# *Note*: Logger::Formatter does not escape or sanitize +# the message passed to it. +# Developers should be aware that malicious data (user input) +# may be in the message, and should explicitly escape untrusted data. +# +# You can use a custom formatter to escape message data; +# see the example at {formatter=}[Logger.html#attribute-i-formatter]. +# +# === Program Name +# +# The program name is an optional argument to an entry method: +# +# logger = Logger.new($stdout) +# logger.add(Logger::INFO, 'My message', 'mung') +# # => I, [2022-05-07T18:17:38.084716 #20536] INFO -- mung: My message +# +# The default program name for a new logger may be set in the call to +# Logger.new via optional keyword argument +progname+: +# +# logger = Logger.new('t.log', progname: 'mung') +# +# The default program name for an existing logger may be set +# by a call to method #progname=: +# +# logger.progname = 'mung' +# +# The current program name may be retrieved with method +# {progname}[Logger.html#attribute-i-progname]: +# +# logger.progname # => "mung" +# +# == Log Level +# +# The log level setting determines whether an entry is actually +# written to the log, based on the entry's severity. +# +# These are the defined severities (least severe to most severe): +# +# logger = Logger.new($stdout) +# logger.add(Logger::DEBUG, 'Maximal debugging info') +# # => D, [2022-05-07T17:57:41.776220 #20536] DEBUG -- : Maximal debugging info +# logger.add(Logger::INFO, 'Non-error information') +# # => I, [2022-05-07T17:59:14.349167 #20536] INFO -- : Non-error information +# logger.add(Logger::WARN, 'Non-error warning') +# # => W, [2022-05-07T18:00:45.337538 #20536] WARN -- : Non-error warning +# logger.add(Logger::ERROR, 'Non-fatal error') +# # => E, [2022-05-07T18:02:41.592912 #20536] ERROR -- : Non-fatal error +# logger.add(Logger::FATAL, 'Fatal error') +# # => F, [2022-05-07T18:05:24.703931 #20536] FATAL -- : Fatal error +# logger.add(Logger::UNKNOWN, 'Most severe') +# # => A, [2022-05-07T18:07:54.657491 #20536] ANY -- : Most severe +# +# The default initial level setting is Logger::DEBUG, the lowest level, +# which means that all entries are to be written, regardless of severity: +# +# logger = Logger.new($stdout) +# logger.level # => 0 +# logger.add(0, "My message") +# # => D, [2022-05-11T15:10:59.773668 #20536] DEBUG -- : My message +# +# You can specify a different setting in a new logger +# using keyword argument +level+ with an appropriate value: +# +# logger = Logger.new($stdout, level: Logger::ERROR) +# logger = Logger.new($stdout, level: 'error') +# logger = Logger.new($stdout, level: :error) +# logger.level # => 3 +# +# With this level, entries with severity Logger::ERROR and higher +# are written, while those with lower severities are not written: +# +# logger = Logger.new($stdout, level: Logger::ERROR) +# logger.add(3) +# # => E, [2022-05-11T15:17:20.933362 #20536] ERROR -- : nil +# logger.add(2) # Silent. +# +# You can set the log level for an existing logger +# with method #level=: +# +# logger.level = Logger::ERROR +# +# These shorthand methods also set the level: +# +# logger.debug! # => 0 +# logger.info! # => 1 +# logger.warn! # => 2 +# logger.error! # => 3 +# logger.fatal! # => 4 +# +# You can retrieve the log level with method #level. +# +# logger.level = Logger::ERROR +# logger.level # => 3 +# +# These methods return whether a given +# level is to be written: +# +# logger.level = Logger::ERROR +# logger.debug? # => false +# logger.info? # => false +# logger.warn? # => false +# logger.error? # => true +# logger.fatal? # => true +# +# == Log File Rotation +# +# By default, a log file is a single file that grows indefinitely +# (until explicitly closed); there is no file rotation. +# +# To keep log files to a manageable size, +# you can use _log_ _file_ _rotation_, which uses multiple log files: +# +# - Each log file has entries for a non-overlapping +# time interval. +# - Only the most recent log file is open and active; +# the others are closed and inactive. +# +# === Size-Based Rotation +# +# For size-based log file rotation, call Logger.new with: +# +# - Argument +logdev+ as a file path. +# - Argument +shift_age+ with a positive integer: +# the number of log files to be in the rotation. +# - Argument +shift_size+ as a positive integer: +# the maximum size (in bytes) of each log file; +# defaults to 1048576 (1 megabyte). +# +# Examples: +# +# logger = Logger.new('t.log', 3) # Three 1-megabyte files. +# logger = Logger.new('t.log', 5, 10485760) # Five 10-megabyte files. +# +# For these examples, suppose: +# +# logger = Logger.new('t.log', 3) +# +# Logging begins in the new log file, +t.log+; +# the log file is "full" and ready for rotation +# when a new entry would cause its size to exceed +shift_size+. +# +# The first time +t.log+ is full: +# +# - +t.log+ is closed and renamed to +t.log.0+. +# - A new file +t.log+ is opened. +# +# The second time +t.log+ is full: +# +# - +t.log.0 is renamed as +t.log.1+. +# - +t.log+ is closed and renamed to +t.log.0+. +# - A new file +t.log+ is opened. +# +# Each subsequent time that +t.log+ is full, +# the log files are rotated: +# +# - +t.log.1+ is removed. +# - +t.log.0 is renamed as +t.log.1+. +# - +t.log+ is closed and renamed to +t.log.0+. +# - A new file +t.log+ is opened. +# +# === Periodic Rotation +# +# For periodic rotation, call Logger.new with: +# +# - Argument +logdev+ as a file path. +# - Argument +shift_age+ as a string period indicator. +# +# Examples: +# +# logger = Logger.new('t.log', 'daily') # Rotate log files daily. +# logger = Logger.new('t.log', 'weekly') # Rotate log files weekly. +# logger = Logger.new('t.log', 'monthly') # Rotate log files monthly. +# +# Example: +# +# logger = Logger.new('t.log', 'daily') +# +# When the given period expires: +# +# - The base log file, +t.log+ is closed and renamed +# with a date-based suffix such as +t.log.20220509+. +# - A new log file +t.log+ is opened. +# - Nothing is removed. +# +# The default format for the suffix is '%Y%m%d', +# which produces a suffix similar to the one above. +# You can set a different format using create-time option +# +shift_period_suffix+; +# see details and suggestions at +# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]. +# +class Logger + _, name, rev = %w$Id$ + if name + name = name.chomp(",v") + else + name = File.basename(__FILE__) + end + rev ||= "v#{VERSION}" + ProgName = "#{name}/#{rev}" + + include Severity + + # Logging severity threshold (e.g. Logger::INFO). + def level + level_override[Fiber.current] || @level + end + + # Sets the log level; returns +severity+. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + # Argument +severity+ may be an integer, a string, or a symbol: + # + # logger.level = Logger::ERROR # => 3 + # logger.level = 3 # => 3 + # logger.level = 'error' # => "error" + # logger.level = :error # => :error + # + # Logger#sev_threshold= is an alias for Logger#level=. + # + def level=(severity) + @level = Severity.coerce(severity) + end + + # Adjust the log level during the block execution for the current Fiber only + # + # logger.with_level(:debug) do + # logger.debug { "Hello" } + # end + def with_level(severity) + prev, level_override[Fiber.current] = level, Severity.coerce(severity) + begin + yield + ensure + if prev + level_override[Fiber.current] = prev + else + level_override.delete(Fiber.current) + end + end + end + + # Program name to include in log messages. + attr_accessor :progname + + # Sets the date-time format. + # + # Argument +datetime_format+ should be either of these: + # + # - A string suitable for use as a format for method + # {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]. + # - +nil+: the logger uses '%Y-%m-%dT%H:%M:%S.%6N'. + # + def datetime_format=(datetime_format) + @default_formatter.datetime_format = datetime_format + end + + # Returns the date-time format; see #datetime_format=. + # + def datetime_format + @default_formatter.datetime_format + end + + # Sets or retrieves the logger entry formatter proc. + # + # When +formatter+ is +nil+, the logger uses Logger::Formatter. + # + # When +formatter+ is a proc, a new entry is formatted by the proc, + # which is called with four arguments: + # + # - +severity+: The severity of the entry. + # - +time+: A Time object representing the entry's timestamp. + # - +progname+: The program name for the entry. + # - +msg+: The message for the entry (string or string-convertible object). + # + # The proc should return a string containing the formatted entry. + # + # This custom formatter uses + # {String#dump}[https://docs.ruby-lang.org/en/master/String.html#method-i-dump] + # to escape the message string: + # + # logger = Logger.new($stdout, progname: 'mung') + # original_formatter = logger.formatter || Logger::Formatter.new + # logger.formatter = proc { |severity, time, progname, msg| + # original_formatter.call(severity, time, progname, msg.dump) + # } + # logger.add(Logger::INFO, "hello \n ''") + # logger.add(Logger::INFO, "\f\x00\xff\\\"") + # + # Output: + # + # I, [2022-05-13T13:16:29.637488 #8492] INFO -- mung: "hello \n ''" + # I, [2022-05-13T13:16:29.637610 #8492] INFO -- mung: "\f\x00\xFF\\\"" + # + attr_accessor :formatter + + alias sev_threshold level + alias sev_threshold= level= + + # Returns +true+ if the log level allows entries with severity + # Logger::DEBUG to be written, +false+ otherwise. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def debug?; level <= DEBUG; end + + # Sets the log level to Logger::DEBUG. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def debug!; self.level = DEBUG; end + + # Returns +true+ if the log level allows entries with severity + # Logger::INFO to be written, +false+ otherwise. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def info?; level <= INFO; end + + # Sets the log level to Logger::INFO. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def info!; self.level = INFO; end + + # Returns +true+ if the log level allows entries with severity + # Logger::WARN to be written, +false+ otherwise. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def warn?; level <= WARN; end + + # Sets the log level to Logger::WARN. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def warn!; self.level = WARN; end + + # Returns +true+ if the log level allows entries with severity + # Logger::ERROR to be written, +false+ otherwise. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def error?; level <= ERROR; end + + # Sets the log level to Logger::ERROR. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def error!; self.level = ERROR; end + + # Returns +true+ if the log level allows entries with severity + # Logger::FATAL to be written, +false+ otherwise. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def fatal?; level <= FATAL; end + + # Sets the log level to Logger::FATAL. + # See {Log Level}[rdoc-ref:Logger@Log+Level]. + # + def fatal!; self.level = FATAL; end + + # :call-seq: + # Logger.new(logdev, shift_age = 0, shift_size = 1048576, **options) + # + # With the single argument +logdev+, + # returns a new logger with all default options: + # + # Logger.new('t.log') # => # + # + # Argument +logdev+ must be one of: + # + # - A string filepath: entries are to be written + # to the file at that path; if the file at that path exists, + # new entries are appended. + # - An IO stream (typically +$stdout+, +$stderr+. or an open file): + # entries are to be written to the given stream. + # - +nil+ or +File::NULL+: no entries are to be written. + # + # Examples: + # + # Logger.new('t.log') + # Logger.new($stdout) + # + # The keyword options are: + # + # - +level+: sets the log level; default value is Logger::DEBUG. + # See {Log Level}[rdoc-ref:Logger@Log+Level]: + # + # Logger.new('t.log', level: Logger::ERROR) + # + # - +progname+: sets the default program name; default is +nil+. + # See {Program Name}[rdoc-ref:Logger@Program+Name]: + # + # Logger.new('t.log', progname: 'mung') + # + # - +formatter+: sets the entry formatter; default is +nil+. + # See {formatter=}[Logger.html#attribute-i-formatter]. + # - +datetime_format+: sets the format for entry timestamp; + # default is +nil+. + # See #datetime_format=. + # - +binmode+: sets whether the logger writes in binary mode; + # default is +false+. + # - +shift_period_suffix+: sets the format for the filename suffix + # for periodic log file rotation; default is '%Y%m%d'. + # See {Periodic Rotation}[rdoc-ref:Logger@Periodic+Rotation]. + # - +reraise_write_errors+: An array of exception classes, which will + # be reraised if there is an error when writing to the log device. + # The default is to swallow all exceptions raised. + # + def initialize(logdev, shift_age = 0, shift_size = 1048576, level: DEBUG, + progname: nil, formatter: nil, datetime_format: nil, + binmode: false, shift_period_suffix: '%Y%m%d', + reraise_write_errors: []) + self.level = level + self.progname = progname + @default_formatter = Formatter.new + self.datetime_format = datetime_format + self.formatter = formatter + @logdev = nil + @level_override = {} + if logdev && logdev != File::NULL + @logdev = LogDevice.new(logdev, shift_age: shift_age, + shift_size: shift_size, + shift_period_suffix: shift_period_suffix, + binmode: binmode, + reraise_write_errors: reraise_write_errors) + end + end + + # Sets the logger's output stream: + # + # - If +logdev+ is +nil+, reopens the current output stream. + # - If +logdev+ is a filepath, opens the indicated file for append. + # - If +logdev+ is an IO stream + # (usually $stdout, $stderr, or an open File object), + # opens the stream for append. + # + # Example: + # + # logger = Logger.new('t.log') + # logger.add(Logger::ERROR, 'one') + # logger.close + # logger.add(Logger::ERROR, 'two') # Prints 'log writing failed. closed stream' + # logger.reopen + # logger.add(Logger::ERROR, 'three') + # logger.close + # File.readlines('t.log') + # # => + # # ["# Logfile created on 2022-05-12 14:21:19 -0500 by logger.rb/v1.5.0\n", + # # "E, [2022-05-12T14:21:27.596726 #22428] ERROR -- : one\n", + # # "E, [2022-05-12T14:23:05.847241 #22428] ERROR -- : three\n"] + # + def reopen(logdev = nil) + @logdev&.reopen(logdev) + self + end + + # Creates a log entry, which may or may not be written to the log, + # depending on the entry's severity and on the log level. + # See {Log Level}[rdoc-ref:Logger@Log+Level] + # and {Entries}[rdoc-ref:Logger@Entries] for details. + # + # Examples: + # + # logger = Logger.new($stdout, progname: 'mung') + # logger.add(Logger::INFO) + # logger.add(Logger::ERROR, 'No good') + # logger.add(Logger::ERROR, 'No good', 'gnum') + # + # Output: + # + # I, [2022-05-12T16:25:31.469726 #36328] INFO -- mung: mung + # E, [2022-05-12T16:25:55.349414 #36328] ERROR -- mung: No good + # E, [2022-05-12T16:26:35.841134 #36328] ERROR -- gnum: No good + # + # These convenience methods have implicit severity: + # + # - #debug. + # - #info. + # - #warn. + # - #error. + # - #fatal. + # - #unknown. + # + def add(severity, message = nil, progname = nil) + severity ||= UNKNOWN + if @logdev.nil? or severity < level + return true + end + if progname.nil? + progname = @progname + end + if message.nil? + if block_given? + message = yield + else + message = progname + progname = @progname + end + end + @logdev.write( + format_message(format_severity(severity), Time.now, progname, message)) + true + end + alias log add + + # Writes the given +msg+ to the log with no formatting; + # returns the number of characters written, + # or +nil+ if no log device exists: + # + # logger = Logger.new($stdout) + # logger << 'My message.' # => 10 + # + # Output: + # + # My message. + # + def <<(msg) + @logdev&.write(msg) + end + + # Equivalent to calling #add with severity Logger::DEBUG. + # + def debug(progname = nil, &block) + add(DEBUG, nil, progname, &block) + end + + # Equivalent to calling #add with severity Logger::INFO. + # + def info(progname = nil, &block) + add(INFO, nil, progname, &block) + end + + # Equivalent to calling #add with severity Logger::WARN. + # + def warn(progname = nil, &block) + add(WARN, nil, progname, &block) + end + + # Equivalent to calling #add with severity Logger::ERROR. + # + def error(progname = nil, &block) + add(ERROR, nil, progname, &block) + end + + # Equivalent to calling #add with severity Logger::FATAL. + # + def fatal(progname = nil, &block) + add(FATAL, nil, progname, &block) + end + + # Equivalent to calling #add with severity Logger::UNKNOWN. + # + def unknown(progname = nil, &block) + add(UNKNOWN, nil, progname, &block) + end + + # Closes the logger; returns +nil+: + # + # logger = Logger.new('t.log') + # logger.close # => nil + # logger.info('foo') # Prints "log writing failed. closed stream" + # + # Related: Logger#reopen. + def close + @logdev&.close + end + +private + + # \Severity label for logging (max 5 chars). + SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY).freeze + + def format_severity(severity) + SEV_LABEL[severity] || 'ANY' + end + + # Guarantee the existence of this ivar even when subclasses don't call the superclass constructor. + def level_override + @level_override ||= {} + end + + def format_message(severity, datetime, progname, msg) + (@formatter || @default_formatter).call(severity, datetime, progname, msg) + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb new file mode 100644 index 0000000000..88581793f0 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb new file mode 100644 index 0000000000..c634dbf34d --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb new file mode 100644 index 0000000000..4876adf0b7 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb @@ -0,0 +1,214 @@ +# 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: []) + @dev = @filename = @shift_age = @shift_size = @shift_period_suffix = nil + @binmode = binmode + @reraise_write_errors = reraise_write_errors + 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' + + 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 write(message) + begin + synchronize do + if @shift_age and @dev.respond_to?(:stat) + begin + check_shift_log + rescue *@reraise_write_errors + raise + rescue + warn("log shifting failed. #{$!}") + end + end + begin + @dev.write(message) + rescue *@reraise_write_errors + raise + rescue + warn("log writing failed. #{$!}") + end + end + rescue *@reraise_write_errors + raise + rescue Exception => ignored + warn("log writing failed. #{ignored}") + end + end + + def close + begin + synchronize do + @dev.close rescue nil + end + rescue Exception + @dev.close rescue nil + end + end + + def reopen(log = nil) + # reopen the same filename if no argument, do nothing for IO + log ||= @filename if @filename + if log + synchronize do + if @filename and @dev + @dev.close rescue nil # close only file opened by Logger + @filename = nil + end + set_dev(log) + end + end + self + end + + private + + 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) + @dev.sync = true + @dev.binmode if @binmode + @filename = log + end + end + + def open_logfile(filename) + begin + File.open(filename, (File::WRONLY | File::APPEND)) + rescue Errno::ENOENT + create_logfile(filename) + end + end + + def create_logfile(filename) + begin + logdev = File.open(filename, (File::WRONLY | File::APPEND | File::CREAT | File::EXCL)) + logdev.flock(File::LOCK_EX) + logdev.sync = true + logdev.binmode if @binmode + add_log_header(logdev) + logdev.flock(File::LOCK_UN) + rescue Errno::EEXIST + # file is created by another process + logdev = open_logfile(filename) + logdev.sync = true + end + logdev + 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 + + if /mswin|mingw|cygwin/ =~ RbConfig::CONFIG['host_os'] + def lock_shift_log + yield + end + else + def lock_shift_log + retry_limit = 8 + retry_sleep = 0.1 + begin + File.open(@filename, File::WRONLY | File::APPEND) 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) + @dev.sync = true + end + end + 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 + 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 + @dev.close rescue nil + File.rename("#{@filename}", "#{@filename}.0") + @dev = create_logfile(@filename) + return true + 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 + @dev.close rescue nil + File.rename("#{@filename}", age_file) + @dev = create_logfile(@filename) + return true + end + end +end diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb new file mode 100644 index 0000000000..a0359defe3 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb new file mode 100644 index 0000000000..e96fb0d320 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb new file mode 100644 index 0000000000..2a0801be63 --- /dev/null +++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb @@ -0,0 +1,5 @@ +# frozen_string_literal: true + +class Logger + VERSION = "1.6.1" +end From 62273bdcd52b290930a19000a20ca99b11461bf0 Mon Sep 17 00:00:00 2001 From: BrewTestBot <1589480+BrewTestBot@users.noreply.github.com> Date: Wed, 4 Sep 2024 16:56:49 +0000 Subject: [PATCH 3/4] Update RBI files for logger. Autogenerated by the [vendor-gems](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/vendor-gems.yml) workflow. --- .../{logger@1.6.0.rbi => logger@1.6.1.rbi} | 161 ++++++++++-------- 1 file changed, 89 insertions(+), 72 deletions(-) rename Library/Homebrew/sorbet/rbi/gems/{logger@1.6.0.rbi => logger@1.6.1.rbi} (86%) diff --git a/Library/Homebrew/sorbet/rbi/gems/logger@1.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/logger@1.6.1.rbi similarity index 86% rename from Library/Homebrew/sorbet/rbi/gems/logger@1.6.0.rbi rename to Library/Homebrew/sorbet/rbi/gems/logger@1.6.1.rbi index 5b699ff015..4e9ceacc7e 100644 --- a/Library/Homebrew/sorbet/rbi/gems/logger@1.6.0.rbi +++ b/Library/Homebrew/sorbet/rbi/gems/logger@1.6.1.rbi @@ -133,7 +133,7 @@ # when the entry is created. # # The logged timestamp is formatted by method -# {Time#strftime}[rdoc-ref:Time#strftime] +# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime] # using this format string: # # '%Y-%m-%dT%H:%M:%S.%6N' @@ -350,7 +350,9 @@ # You can set a different format using create-time option # +shift_period_suffix+; # see details and suggestions at -# {Time#strftime}[rdoc-ref:Time#strftime]. +# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]. +# +# source://logger//lib/logger/version.rb#3 class Logger include ::Logger::Severity @@ -398,11 +400,14 @@ class Logger # - +shift_period_suffix+: sets the format for the filename suffix # for periodic log file rotation; default is '%Y%m%d'. # See {Periodic Rotation}[rdoc-ref:Logger@Periodic+Rotation]. + # - +reraise_write_errors+: An array of exception classes, which will + # be reraised if there is an error when writing to the log device. + # The default is to swallow all exceptions raised. # # @return [Logger] a new instance of Logger # - # source://logger//logger.rb#578 - def initialize(logdev, shift_age = T.unsafe(nil), shift_size = T.unsafe(nil), level: T.unsafe(nil), progname: T.unsafe(nil), formatter: T.unsafe(nil), datetime_format: T.unsafe(nil), binmode: T.unsafe(nil), shift_period_suffix: T.unsafe(nil)); end + # source://logger//lib/logger.rb#581 + def initialize(logdev, shift_age = T.unsafe(nil), shift_size = T.unsafe(nil), level: T.unsafe(nil), progname: T.unsafe(nil), formatter: T.unsafe(nil), datetime_format: T.unsafe(nil), binmode: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end # Writes the given +msg+ to the log with no formatting; # returns the number of characters written, @@ -415,7 +420,7 @@ class Logger # # My message. # - # source://logger//logger.rb#684 + # source://logger//lib/logger.rb#689 def <<(msg); end # Creates a log entry, which may or may not be written to the log, @@ -445,7 +450,7 @@ class Logger # - #fatal. # - #unknown. # - # source://logger//logger.rb#651 + # source://logger//lib/logger.rb#656 def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end # Closes the logger; returns +nil+: @@ -456,12 +461,12 @@ class Logger # # Related: Logger#reopen. # - # source://logger//logger.rb#731 + # source://logger//lib/logger.rb#736 def close; end # Returns the date-time format; see #datetime_format=. # - # source://logger//logger.rb#438 + # source://logger//lib/logger.rb#438 def datetime_format; end # Sets the date-time format. @@ -469,21 +474,21 @@ class Logger # Argument +datetime_format+ should be either of these: # # - A string suitable for use as a format for method - # {Time#strftime}[rdoc-ref:Time#strftime]. + # {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]. # - +nil+: the logger uses '%Y-%m-%dT%H:%M:%S.%6N'. # - # source://logger//logger.rb#432 + # source://logger//lib/logger.rb#432 def datetime_format=(datetime_format); end # Equivalent to calling #add with severity Logger::DEBUG. # - # source://logger//logger.rb#690 + # source://logger//lib/logger.rb#695 def debug(progname = T.unsafe(nil), &block); end # Sets the log level to Logger::DEBUG. # See {Log Level}[rdoc-ref:Logger@Log+Level]. # - # source://logger//logger.rb#487 + # source://logger//lib/logger.rb#487 def debug!; end # Returns +true+ if the log level allows entries with severity @@ -492,18 +497,18 @@ class Logger # # @return [Boolean] # - # source://logger//logger.rb#482 + # source://logger//lib/logger.rb#482 def debug?; end # Equivalent to calling #add with severity Logger::ERROR. # - # source://logger//logger.rb#708 + # source://logger//lib/logger.rb#713 def error(progname = T.unsafe(nil), &block); end # Sets the log level to Logger::ERROR. # See {Log Level}[rdoc-ref:Logger@Log+Level]. # - # source://logger//logger.rb#520 + # source://logger//lib/logger.rb#520 def error!; end # Returns +true+ if the log level allows entries with severity @@ -512,18 +517,18 @@ class Logger # # @return [Boolean] # - # source://logger//logger.rb#515 + # source://logger//lib/logger.rb#515 def error?; end # Equivalent to calling #add with severity Logger::FATAL. # - # source://logger//logger.rb#714 + # source://logger//lib/logger.rb#719 def fatal(progname = T.unsafe(nil), &block); end # Sets the log level to Logger::FATAL. # See {Log Level}[rdoc-ref:Logger@Log+Level]. # - # source://logger//logger.rb#531 + # source://logger//lib/logger.rb#531 def fatal!; end # Returns +true+ if the log level allows entries with severity @@ -532,7 +537,7 @@ class Logger # # @return [Boolean] # - # source://logger//logger.rb#526 + # source://logger//lib/logger.rb#526 def fatal?; end # Sets or retrieves the logger entry formatter proc. @@ -550,7 +555,7 @@ class Logger # The proc should return a string containing the formatted entry. # # This custom formatter uses - # {String#dump}[rdoc-ref:String#dump] + # {String#dump}[https://docs.ruby-lang.org/en/master/String.html#method-i-dump] # to escape the message string: # # logger = Logger.new($stdout, progname: 'mung') @@ -566,7 +571,7 @@ class Logger # I, [2022-05-13T13:16:29.637488 #8492] INFO -- mung: "hello \n ''" # I, [2022-05-13T13:16:29.637610 #8492] INFO -- mung: "\f\x00\xFF\\\"" # - # source://logger//logger.rb#473 + # source://logger//lib/logger.rb#473 def formatter; end # Sets or retrieves the logger entry formatter proc. @@ -584,7 +589,7 @@ class Logger # The proc should return a string containing the formatted entry. # # This custom formatter uses - # {String#dump}[rdoc-ref:String#dump] + # {String#dump}[https://docs.ruby-lang.org/en/master/String.html#method-i-dump] # to escape the message string: # # logger = Logger.new($stdout, progname: 'mung') @@ -600,18 +605,18 @@ class Logger # I, [2022-05-13T13:16:29.637488 #8492] INFO -- mung: "hello \n ''" # I, [2022-05-13T13:16:29.637610 #8492] INFO -- mung: "\f\x00\xFF\\\"" # - # source://logger//logger.rb#473 + # source://logger//lib/logger.rb#473 def formatter=(_arg0); end # Equivalent to calling #add with severity Logger::INFO. # - # source://logger//logger.rb#696 + # source://logger//lib/logger.rb#701 def info(progname = T.unsafe(nil), &block); end # Sets the log level to Logger::INFO. # See {Log Level}[rdoc-ref:Logger@Log+Level]. # - # source://logger//logger.rb#498 + # source://logger//lib/logger.rb#498 def info!; end # Returns +true+ if the log level allows entries with severity @@ -620,12 +625,12 @@ class Logger # # @return [Boolean] # - # source://logger//logger.rb#493 + # source://logger//lib/logger.rb#493 def info?; end # Logging severity threshold (e.g. Logger::INFO). # - # source://logger//logger.rb#383 + # source://logger//lib/logger.rb#383 def level; end # Sets the log level; returns +severity+. @@ -640,7 +645,7 @@ class Logger # # Logger#sev_threshold= is an alias for Logger#level=. # - # source://logger//logger.rb#399 + # source://logger//lib/logger.rb#399 def level=(severity); end # Creates a log entry, which may or may not be written to the log, @@ -670,17 +675,17 @@ class Logger # - #fatal. # - #unknown. # - # source://logger//logger.rb#651 + # source://logger//lib/logger.rb#656 def log(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end # Program name to include in log messages. # - # source://logger//logger.rb#422 + # source://logger//lib/logger.rb#422 def progname; end # Program name to include in log messages. # - # source://logger//logger.rb#422 + # source://logger//lib/logger.rb#422 def progname=(_arg0); end # Sets the logger's output stream: @@ -706,12 +711,12 @@ class Logger # # "E, [2022-05-12T14:21:27.596726 #22428] ERROR -- : one\n", # # "E, [2022-05-12T14:23:05.847241 #22428] ERROR -- : three\n"] # - # source://logger//logger.rb#619 + # source://logger//lib/logger.rb#624 def reopen(logdev = T.unsafe(nil)); end # Logging severity threshold (e.g. Logger::INFO). # - # source://logger//logger.rb#383 + # source://logger//lib/logger.rb#383 def sev_threshold; end # Sets the log level; returns +severity+. @@ -726,23 +731,23 @@ class Logger # # Logger#sev_threshold= is an alias for Logger#level=. # - # source://logger//logger.rb#399 + # source://logger//lib/logger.rb#399 def sev_threshold=(severity); end # Equivalent to calling #add with severity Logger::UNKNOWN. # - # source://logger//logger.rb#720 + # source://logger//lib/logger.rb#725 def unknown(progname = T.unsafe(nil), &block); end # Equivalent to calling #add with severity Logger::WARN. # - # source://logger//logger.rb#702 + # source://logger//lib/logger.rb#707 def warn(progname = T.unsafe(nil), &block); end # Sets the log level to Logger::WARN. # See {Log Level}[rdoc-ref:Logger@Log+Level]. # - # source://logger//logger.rb#509 + # source://logger//lib/logger.rb#509 def warn!; end # Returns +true+ if the log level allows entries with severity @@ -751,7 +756,7 @@ class Logger # # @return [Boolean] # - # source://logger//logger.rb#504 + # source://logger//lib/logger.rb#504 def warn?; end # Adjust the log level during the block execution for the current Fiber only @@ -760,144 +765,156 @@ class Logger # logger.debug { "Hello" } # end # - # source://logger//logger.rb#408 + # source://logger//lib/logger.rb#408 def with_level(severity); end private - # source://logger//logger.rb#744 + # source://logger//lib/logger.rb#754 def format_message(severity, datetime, progname, msg); end - # source://logger//logger.rb#740 + # source://logger//lib/logger.rb#745 def format_severity(severity); end + + # Guarantee the existence of this ivar even when subclasses don't call the superclass constructor. + # + # source://logger//lib/logger.rb#750 + def level_override; end end # Default formatter for log messages. +# +# source://logger//lib/logger/formatter.rb#5 class Logger::Formatter # @return [Formatter] a new instance of Formatter # - # source://logger//logger/formatter.rb#11 + # source://logger//lib/logger/formatter.rb#11 def initialize; end - # source://logger//logger/formatter.rb#15 + # source://logger//lib/logger/formatter.rb#15 def call(severity, time, progname, msg); end # Returns the value of attribute datetime_format. # - # source://logger//logger/formatter.rb#9 + # source://logger//lib/logger/formatter.rb#9 def datetime_format; end # Sets the attribute datetime_format # # @param value the value to set the attribute datetime_format to. # - # source://logger//logger/formatter.rb#9 + # source://logger//lib/logger/formatter.rb#9 def datetime_format=(_arg0); end private - # source://logger//logger/formatter.rb#21 + # source://logger//lib/logger/formatter.rb#21 def format_datetime(time); end - # source://logger//logger/formatter.rb#25 + # source://logger//lib/logger/formatter.rb#25 def msg2str(msg); end end -# source://logger//logger/formatter.rb#7 +# source://logger//lib/logger/formatter.rb#7 Logger::Formatter::DatetimeFormat = T.let(T.unsafe(nil), String) -# source://logger//logger/formatter.rb#6 +# source://logger//lib/logger/formatter.rb#6 Logger::Formatter::Format = T.let(T.unsafe(nil), String) # Device used for logging messages. +# +# source://logger//lib/logger/log_device.rb#7 class Logger::LogDevice include ::Logger::Period include ::MonitorMixin # @return [LogDevice] a new instance of LogDevice # - # source://logger//logger/log_device.rb#14 - def initialize(log = T.unsafe(nil), shift_age: T.unsafe(nil), shift_size: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), binmode: T.unsafe(nil)); end + # source://logger//lib/logger/log_device.rb#14 + def initialize(log = T.unsafe(nil), shift_age: T.unsafe(nil), shift_size: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), binmode: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end - # source://logger//logger/log_device.rb#52 + # source://logger//lib/logger/log_device.rb#59 def close; end # Returns the value of attribute dev. # - # source://logger//logger/log_device.rb#10 + # source://logger//lib/logger/log_device.rb#10 def dev; end # Returns the value of attribute filename. # - # source://logger//logger/log_device.rb#11 + # source://logger//lib/logger/log_device.rb#11 def filename; end - # source://logger//logger/log_device.rb#62 + # source://logger//lib/logger/log_device.rb#69 def reopen(log = T.unsafe(nil)); end - # source://logger//logger/log_device.rb#31 + # source://logger//lib/logger/log_device.rb#32 def write(message); end private - # source://logger//logger/log_device.rb#119 + # source://logger//lib/logger/log_device.rb#126 def add_log_header(file); end - # source://logger//logger/log_device.rb#125 + # source://logger//lib/logger/log_device.rb#132 def check_shift_log; end - # source://logger//logger/log_device.rb#103 + # source://logger//lib/logger/log_device.rb#110 def create_logfile(filename); end - # source://logger//logger/log_device.rb#145 + # source://logger//lib/logger/log_device.rb#152 def lock_shift_log; end - # source://logger//logger/log_device.rb#95 + # source://logger//lib/logger/log_device.rb#102 def open_logfile(filename); end - # source://logger//logger/log_device.rb#79 + # source://logger//lib/logger/log_device.rb#86 def set_dev(log); end - # source://logger//logger/log_device.rb#176 + # source://logger//lib/logger/log_device.rb#183 def shift_log_age; end - # source://logger//logger/log_device.rb#188 + # source://logger//lib/logger/log_device.rb#195 def shift_log_period(period_end); end end +# source://logger//lib/logger/period.rb#4 module Logger::Period private - # source://logger//logger/period.rb#9 + # source://logger//lib/logger/period.rb#9 def next_rotate_time(now, shift_age); end - # source://logger//logger/period.rb#31 + # source://logger//lib/logger/period.rb#31 def previous_period_end(now, shift_age); end class << self - # source://logger//logger/period.rb#9 + # source://logger//lib/logger/period.rb#9 def next_rotate_time(now, shift_age); end - # source://logger//logger/period.rb#31 + # source://logger//lib/logger/period.rb#31 def previous_period_end(now, shift_age); end end end -# source://logger//logger/period.rb#7 +# source://logger//lib/logger/period.rb#7 Logger::Period::SiD = T.let(T.unsafe(nil), Integer) # \Severity label for logging (max 5 chars). # -# source://logger//logger.rb#738 +# source://logger//lib/logger.rb#743 Logger::SEV_LABEL = T.let(T.unsafe(nil), Array) # Logging severity. +# +# source://logger//lib/logger/severity.rb#5 module Logger::Severity class << self - # source://logger//logger/severity.rb#29 + # source://logger//lib/logger/severity.rb#29 def coerce(severity); end end end -# source://logger//logger/severity.rb#19 +# source://logger//lib/logger/severity.rb#19 Logger::Severity::LEVELS = T.let(T.unsafe(nil), Hash) From c6c7373a609affdd15511a7b460fcb8c90b17ca6 Mon Sep 17 00:00:00 2001 From: Patrick Linnane Date: Wed, 4 Sep 2024 10:54:09 -0700 Subject: [PATCH 4/4] gems/logger: add to `.gitignore` Signed-off-by: Patrick Linnane --- .gitignore | 1 + .../3.3.0/gems/logger-1.6.1/lib/logger.rb | 757 ------------------ .../gems/logger-1.6.1/lib/logger/errors.rb | 9 - .../gems/logger-1.6.1/lib/logger/formatter.rb | 36 - .../logger-1.6.1/lib/logger/log_device.rb | 214 ----- .../gems/logger-1.6.1/lib/logger/period.rb | 47 -- .../gems/logger-1.6.1/lib/logger/severity.rb | 38 - .../gems/logger-1.6.1/lib/logger/version.rb | 5 - 8 files changed, 1 insertion(+), 1106 deletions(-) delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb delete mode 100644 Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb diff --git a/.gitignore b/.gitignore index 63ef5b980b..065d40a469 100644 --- a/.gitignore +++ b/.gitignore @@ -89,6 +89,7 @@ **/vendor/bundle/ruby/*/gems/json_schemer-*/ **/vendor/bundle/ruby/*/gems/kramdown-*/ **/vendor/bundle/ruby/*/gems/language_server-protocol-*/ +**/vendor/bundle/ruby/*/gems/logger-*/ **/vendor/bundle/ruby/*/gems/method_source-*/ **/vendor/bundle/ruby/*/gems/mini_portile2-*/ **/vendor/bundle/ruby/*/gems/minitest-*/ diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb deleted file mode 100644 index 47352097fd..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger.rb +++ /dev/null @@ -1,757 +0,0 @@ -# frozen_string_literal: true -# logger.rb - simple logging utility -# Copyright (C) 2000-2003, 2005, 2008, 2011 NAKAMURA, Hiroshi . -# -# Documentation:: NAKAMURA, Hiroshi and Gavin Sinclair -# License:: -# You can redistribute it and/or modify it under the same terms of Ruby's -# license; either the dual license version in 2003, or any later version. -# Revision:: $Id$ -# -# A simple system for logging messages. See Logger for more documentation. - -require 'fiber' -require 'monitor' -require 'rbconfig' - -require_relative 'logger/version' -require_relative 'logger/formatter' -require_relative 'logger/log_device' -require_relative 'logger/severity' -require_relative 'logger/errors' - -# \Class \Logger provides a simple but sophisticated logging utility that -# you can use to create one or more -# {event logs}[https://en.wikipedia.org/wiki/Logging_(software)#Event_logs] -# for your program. -# Each such log contains a chronological sequence of entries -# that provides a record of the program's activities. -# -# == About the Examples -# -# All examples on this page assume that \Logger has been required: -# -# require 'logger' -# -# == Synopsis -# -# Create a log with Logger.new: -# -# # Single log file. -# logger = Logger.new('t.log') -# # Size-based rotated logging: 3 10-megabyte files. -# logger = Logger.new('t.log', 3, 10485760) -# # Period-based rotated logging: daily (also allowed: 'weekly', 'monthly'). -# logger = Logger.new('t.log', 'daily') -# # Log to an IO stream. -# logger = Logger.new($stdout) -# -# Add entries (level, message) with Logger#add: -# -# logger.add(Logger::DEBUG, 'Maximal debugging info') -# logger.add(Logger::INFO, 'Non-error information') -# logger.add(Logger::WARN, 'Non-error warning') -# logger.add(Logger::ERROR, 'Non-fatal error') -# logger.add(Logger::FATAL, 'Fatal error') -# logger.add(Logger::UNKNOWN, 'Most severe') -# -# Close the log with Logger#close: -# -# logger.close -# -# == Entries -# -# You can add entries with method Logger#add: -# -# logger.add(Logger::DEBUG, 'Maximal debugging info') -# logger.add(Logger::INFO, 'Non-error information') -# logger.add(Logger::WARN, 'Non-error warning') -# logger.add(Logger::ERROR, 'Non-fatal error') -# logger.add(Logger::FATAL, 'Fatal error') -# logger.add(Logger::UNKNOWN, 'Most severe') -# -# These shorthand methods also add entries: -# -# logger.debug('Maximal debugging info') -# logger.info('Non-error information') -# logger.warn('Non-error warning') -# logger.error('Non-fatal error') -# logger.fatal('Fatal error') -# logger.unknown('Most severe') -# -# When you call any of these methods, -# the entry may or may not be written to the log, -# depending on the entry's severity and on the log level; -# see {Log Level}[rdoc-ref:Logger@Log+Level] -# -# An entry always has: -# -# - A severity (the required argument to #add). -# - An automatically created timestamp. -# -# And may also have: -# -# - A message. -# - A program name. -# -# Example: -# -# logger = Logger.new($stdout) -# logger.add(Logger::INFO, 'My message.', 'mung') -# # => I, [2022-05-07T17:21:46.536234 #20536] INFO -- mung: My message. -# -# The default format for an entry is: -# -# "%s, [%s #%d] %5s -- %s: %s\n" -# -# where the values to be formatted are: -# -# - \Severity (one letter). -# - Timestamp. -# - Process id. -# - \Severity (word). -# - Program name. -# - Message. -# -# You can use a different entry format by: -# -# - Setting a custom format proc (affects following entries); -# see {formatter=}[Logger.html#attribute-i-formatter]. -# - Calling any of the methods above with a block -# (affects only the one entry). -# Doing so can have two benefits: -# -# - Context: the block can evaluate the entire program context -# and create a context-dependent message. -# - Performance: the block is not evaluated unless the log level -# permits the entry actually to be written: -# -# logger.error { my_slow_message_generator } -# -# Contrast this with the string form, where the string is -# always evaluated, regardless of the log level: -# -# logger.error("#{my_slow_message_generator}") -# -# === \Severity -# -# The severity of a log entry has two effects: -# -# - Determines whether the entry is selected for inclusion in the log; -# see {Log Level}[rdoc-ref:Logger@Log+Level]. -# - Indicates to any log reader (whether a person or a program) -# the relative importance of the entry. -# -# === Timestamp -# -# The timestamp for a log entry is generated automatically -# when the entry is created. -# -# The logged timestamp is formatted by method -# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime] -# using this format string: -# -# '%Y-%m-%dT%H:%M:%S.%6N' -# -# Example: -# -# logger = Logger.new($stdout) -# logger.add(Logger::INFO) -# # => I, [2022-05-07T17:04:32.318331 #20536] INFO -- : nil -# -# You can set a different format using method #datetime_format=. -# -# === Message -# -# The message is an optional argument to an entry method: -# -# logger = Logger.new($stdout) -# logger.add(Logger::INFO, 'My message') -# # => I, [2022-05-07T18:15:37.647581 #20536] INFO -- : My message -# -# For the default entry formatter, Logger::Formatter, -# the message object may be: -# -# - A string: used as-is. -# - An Exception: message.message is used. -# - Anything else: message.inspect is used. -# -# *Note*: Logger::Formatter does not escape or sanitize -# the message passed to it. -# Developers should be aware that malicious data (user input) -# may be in the message, and should explicitly escape untrusted data. -# -# You can use a custom formatter to escape message data; -# see the example at {formatter=}[Logger.html#attribute-i-formatter]. -# -# === Program Name -# -# The program name is an optional argument to an entry method: -# -# logger = Logger.new($stdout) -# logger.add(Logger::INFO, 'My message', 'mung') -# # => I, [2022-05-07T18:17:38.084716 #20536] INFO -- mung: My message -# -# The default program name for a new logger may be set in the call to -# Logger.new via optional keyword argument +progname+: -# -# logger = Logger.new('t.log', progname: 'mung') -# -# The default program name for an existing logger may be set -# by a call to method #progname=: -# -# logger.progname = 'mung' -# -# The current program name may be retrieved with method -# {progname}[Logger.html#attribute-i-progname]: -# -# logger.progname # => "mung" -# -# == Log Level -# -# The log level setting determines whether an entry is actually -# written to the log, based on the entry's severity. -# -# These are the defined severities (least severe to most severe): -# -# logger = Logger.new($stdout) -# logger.add(Logger::DEBUG, 'Maximal debugging info') -# # => D, [2022-05-07T17:57:41.776220 #20536] DEBUG -- : Maximal debugging info -# logger.add(Logger::INFO, 'Non-error information') -# # => I, [2022-05-07T17:59:14.349167 #20536] INFO -- : Non-error information -# logger.add(Logger::WARN, 'Non-error warning') -# # => W, [2022-05-07T18:00:45.337538 #20536] WARN -- : Non-error warning -# logger.add(Logger::ERROR, 'Non-fatal error') -# # => E, [2022-05-07T18:02:41.592912 #20536] ERROR -- : Non-fatal error -# logger.add(Logger::FATAL, 'Fatal error') -# # => F, [2022-05-07T18:05:24.703931 #20536] FATAL -- : Fatal error -# logger.add(Logger::UNKNOWN, 'Most severe') -# # => A, [2022-05-07T18:07:54.657491 #20536] ANY -- : Most severe -# -# The default initial level setting is Logger::DEBUG, the lowest level, -# which means that all entries are to be written, regardless of severity: -# -# logger = Logger.new($stdout) -# logger.level # => 0 -# logger.add(0, "My message") -# # => D, [2022-05-11T15:10:59.773668 #20536] DEBUG -- : My message -# -# You can specify a different setting in a new logger -# using keyword argument +level+ with an appropriate value: -# -# logger = Logger.new($stdout, level: Logger::ERROR) -# logger = Logger.new($stdout, level: 'error') -# logger = Logger.new($stdout, level: :error) -# logger.level # => 3 -# -# With this level, entries with severity Logger::ERROR and higher -# are written, while those with lower severities are not written: -# -# logger = Logger.new($stdout, level: Logger::ERROR) -# logger.add(3) -# # => E, [2022-05-11T15:17:20.933362 #20536] ERROR -- : nil -# logger.add(2) # Silent. -# -# You can set the log level for an existing logger -# with method #level=: -# -# logger.level = Logger::ERROR -# -# These shorthand methods also set the level: -# -# logger.debug! # => 0 -# logger.info! # => 1 -# logger.warn! # => 2 -# logger.error! # => 3 -# logger.fatal! # => 4 -# -# You can retrieve the log level with method #level. -# -# logger.level = Logger::ERROR -# logger.level # => 3 -# -# These methods return whether a given -# level is to be written: -# -# logger.level = Logger::ERROR -# logger.debug? # => false -# logger.info? # => false -# logger.warn? # => false -# logger.error? # => true -# logger.fatal? # => true -# -# == Log File Rotation -# -# By default, a log file is a single file that grows indefinitely -# (until explicitly closed); there is no file rotation. -# -# To keep log files to a manageable size, -# you can use _log_ _file_ _rotation_, which uses multiple log files: -# -# - Each log file has entries for a non-overlapping -# time interval. -# - Only the most recent log file is open and active; -# the others are closed and inactive. -# -# === Size-Based Rotation -# -# For size-based log file rotation, call Logger.new with: -# -# - Argument +logdev+ as a file path. -# - Argument +shift_age+ with a positive integer: -# the number of log files to be in the rotation. -# - Argument +shift_size+ as a positive integer: -# the maximum size (in bytes) of each log file; -# defaults to 1048576 (1 megabyte). -# -# Examples: -# -# logger = Logger.new('t.log', 3) # Three 1-megabyte files. -# logger = Logger.new('t.log', 5, 10485760) # Five 10-megabyte files. -# -# For these examples, suppose: -# -# logger = Logger.new('t.log', 3) -# -# Logging begins in the new log file, +t.log+; -# the log file is "full" and ready for rotation -# when a new entry would cause its size to exceed +shift_size+. -# -# The first time +t.log+ is full: -# -# - +t.log+ is closed and renamed to +t.log.0+. -# - A new file +t.log+ is opened. -# -# The second time +t.log+ is full: -# -# - +t.log.0 is renamed as +t.log.1+. -# - +t.log+ is closed and renamed to +t.log.0+. -# - A new file +t.log+ is opened. -# -# Each subsequent time that +t.log+ is full, -# the log files are rotated: -# -# - +t.log.1+ is removed. -# - +t.log.0 is renamed as +t.log.1+. -# - +t.log+ is closed and renamed to +t.log.0+. -# - A new file +t.log+ is opened. -# -# === Periodic Rotation -# -# For periodic rotation, call Logger.new with: -# -# - Argument +logdev+ as a file path. -# - Argument +shift_age+ as a string period indicator. -# -# Examples: -# -# logger = Logger.new('t.log', 'daily') # Rotate log files daily. -# logger = Logger.new('t.log', 'weekly') # Rotate log files weekly. -# logger = Logger.new('t.log', 'monthly') # Rotate log files monthly. -# -# Example: -# -# logger = Logger.new('t.log', 'daily') -# -# When the given period expires: -# -# - The base log file, +t.log+ is closed and renamed -# with a date-based suffix such as +t.log.20220509+. -# - A new log file +t.log+ is opened. -# - Nothing is removed. -# -# The default format for the suffix is '%Y%m%d', -# which produces a suffix similar to the one above. -# You can set a different format using create-time option -# +shift_period_suffix+; -# see details and suggestions at -# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]. -# -class Logger - _, name, rev = %w$Id$ - if name - name = name.chomp(",v") - else - name = File.basename(__FILE__) - end - rev ||= "v#{VERSION}" - ProgName = "#{name}/#{rev}" - - include Severity - - # Logging severity threshold (e.g. Logger::INFO). - def level - level_override[Fiber.current] || @level - end - - # Sets the log level; returns +severity+. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - # Argument +severity+ may be an integer, a string, or a symbol: - # - # logger.level = Logger::ERROR # => 3 - # logger.level = 3 # => 3 - # logger.level = 'error' # => "error" - # logger.level = :error # => :error - # - # Logger#sev_threshold= is an alias for Logger#level=. - # - def level=(severity) - @level = Severity.coerce(severity) - end - - # Adjust the log level during the block execution for the current Fiber only - # - # logger.with_level(:debug) do - # logger.debug { "Hello" } - # end - def with_level(severity) - prev, level_override[Fiber.current] = level, Severity.coerce(severity) - begin - yield - ensure - if prev - level_override[Fiber.current] = prev - else - level_override.delete(Fiber.current) - end - end - end - - # Program name to include in log messages. - attr_accessor :progname - - # Sets the date-time format. - # - # Argument +datetime_format+ should be either of these: - # - # - A string suitable for use as a format for method - # {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]. - # - +nil+: the logger uses '%Y-%m-%dT%H:%M:%S.%6N'. - # - def datetime_format=(datetime_format) - @default_formatter.datetime_format = datetime_format - end - - # Returns the date-time format; see #datetime_format=. - # - def datetime_format - @default_formatter.datetime_format - end - - # Sets or retrieves the logger entry formatter proc. - # - # When +formatter+ is +nil+, the logger uses Logger::Formatter. - # - # When +formatter+ is a proc, a new entry is formatted by the proc, - # which is called with four arguments: - # - # - +severity+: The severity of the entry. - # - +time+: A Time object representing the entry's timestamp. - # - +progname+: The program name for the entry. - # - +msg+: The message for the entry (string or string-convertible object). - # - # The proc should return a string containing the formatted entry. - # - # This custom formatter uses - # {String#dump}[https://docs.ruby-lang.org/en/master/String.html#method-i-dump] - # to escape the message string: - # - # logger = Logger.new($stdout, progname: 'mung') - # original_formatter = logger.formatter || Logger::Formatter.new - # logger.formatter = proc { |severity, time, progname, msg| - # original_formatter.call(severity, time, progname, msg.dump) - # } - # logger.add(Logger::INFO, "hello \n ''") - # logger.add(Logger::INFO, "\f\x00\xff\\\"") - # - # Output: - # - # I, [2022-05-13T13:16:29.637488 #8492] INFO -- mung: "hello \n ''" - # I, [2022-05-13T13:16:29.637610 #8492] INFO -- mung: "\f\x00\xFF\\\"" - # - attr_accessor :formatter - - alias sev_threshold level - alias sev_threshold= level= - - # Returns +true+ if the log level allows entries with severity - # Logger::DEBUG to be written, +false+ otherwise. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def debug?; level <= DEBUG; end - - # Sets the log level to Logger::DEBUG. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def debug!; self.level = DEBUG; end - - # Returns +true+ if the log level allows entries with severity - # Logger::INFO to be written, +false+ otherwise. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def info?; level <= INFO; end - - # Sets the log level to Logger::INFO. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def info!; self.level = INFO; end - - # Returns +true+ if the log level allows entries with severity - # Logger::WARN to be written, +false+ otherwise. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def warn?; level <= WARN; end - - # Sets the log level to Logger::WARN. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def warn!; self.level = WARN; end - - # Returns +true+ if the log level allows entries with severity - # Logger::ERROR to be written, +false+ otherwise. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def error?; level <= ERROR; end - - # Sets the log level to Logger::ERROR. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def error!; self.level = ERROR; end - - # Returns +true+ if the log level allows entries with severity - # Logger::FATAL to be written, +false+ otherwise. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def fatal?; level <= FATAL; end - - # Sets the log level to Logger::FATAL. - # See {Log Level}[rdoc-ref:Logger@Log+Level]. - # - def fatal!; self.level = FATAL; end - - # :call-seq: - # Logger.new(logdev, shift_age = 0, shift_size = 1048576, **options) - # - # With the single argument +logdev+, - # returns a new logger with all default options: - # - # Logger.new('t.log') # => # - # - # Argument +logdev+ must be one of: - # - # - A string filepath: entries are to be written - # to the file at that path; if the file at that path exists, - # new entries are appended. - # - An IO stream (typically +$stdout+, +$stderr+. or an open file): - # entries are to be written to the given stream. - # - +nil+ or +File::NULL+: no entries are to be written. - # - # Examples: - # - # Logger.new('t.log') - # Logger.new($stdout) - # - # The keyword options are: - # - # - +level+: sets the log level; default value is Logger::DEBUG. - # See {Log Level}[rdoc-ref:Logger@Log+Level]: - # - # Logger.new('t.log', level: Logger::ERROR) - # - # - +progname+: sets the default program name; default is +nil+. - # See {Program Name}[rdoc-ref:Logger@Program+Name]: - # - # Logger.new('t.log', progname: 'mung') - # - # - +formatter+: sets the entry formatter; default is +nil+. - # See {formatter=}[Logger.html#attribute-i-formatter]. - # - +datetime_format+: sets the format for entry timestamp; - # default is +nil+. - # See #datetime_format=. - # - +binmode+: sets whether the logger writes in binary mode; - # default is +false+. - # - +shift_period_suffix+: sets the format for the filename suffix - # for periodic log file rotation; default is '%Y%m%d'. - # See {Periodic Rotation}[rdoc-ref:Logger@Periodic+Rotation]. - # - +reraise_write_errors+: An array of exception classes, which will - # be reraised if there is an error when writing to the log device. - # The default is to swallow all exceptions raised. - # - def initialize(logdev, shift_age = 0, shift_size = 1048576, level: DEBUG, - progname: nil, formatter: nil, datetime_format: nil, - binmode: false, shift_period_suffix: '%Y%m%d', - reraise_write_errors: []) - self.level = level - self.progname = progname - @default_formatter = Formatter.new - self.datetime_format = datetime_format - self.formatter = formatter - @logdev = nil - @level_override = {} - if logdev && logdev != File::NULL - @logdev = LogDevice.new(logdev, shift_age: shift_age, - shift_size: shift_size, - shift_period_suffix: shift_period_suffix, - binmode: binmode, - reraise_write_errors: reraise_write_errors) - end - end - - # Sets the logger's output stream: - # - # - If +logdev+ is +nil+, reopens the current output stream. - # - If +logdev+ is a filepath, opens the indicated file for append. - # - If +logdev+ is an IO stream - # (usually $stdout, $stderr, or an open File object), - # opens the stream for append. - # - # Example: - # - # logger = Logger.new('t.log') - # logger.add(Logger::ERROR, 'one') - # logger.close - # logger.add(Logger::ERROR, 'two') # Prints 'log writing failed. closed stream' - # logger.reopen - # logger.add(Logger::ERROR, 'three') - # logger.close - # File.readlines('t.log') - # # => - # # ["# Logfile created on 2022-05-12 14:21:19 -0500 by logger.rb/v1.5.0\n", - # # "E, [2022-05-12T14:21:27.596726 #22428] ERROR -- : one\n", - # # "E, [2022-05-12T14:23:05.847241 #22428] ERROR -- : three\n"] - # - def reopen(logdev = nil) - @logdev&.reopen(logdev) - self - end - - # Creates a log entry, which may or may not be written to the log, - # depending on the entry's severity and on the log level. - # See {Log Level}[rdoc-ref:Logger@Log+Level] - # and {Entries}[rdoc-ref:Logger@Entries] for details. - # - # Examples: - # - # logger = Logger.new($stdout, progname: 'mung') - # logger.add(Logger::INFO) - # logger.add(Logger::ERROR, 'No good') - # logger.add(Logger::ERROR, 'No good', 'gnum') - # - # Output: - # - # I, [2022-05-12T16:25:31.469726 #36328] INFO -- mung: mung - # E, [2022-05-12T16:25:55.349414 #36328] ERROR -- mung: No good - # E, [2022-05-12T16:26:35.841134 #36328] ERROR -- gnum: No good - # - # These convenience methods have implicit severity: - # - # - #debug. - # - #info. - # - #warn. - # - #error. - # - #fatal. - # - #unknown. - # - def add(severity, message = nil, progname = nil) - severity ||= UNKNOWN - if @logdev.nil? or severity < level - return true - end - if progname.nil? - progname = @progname - end - if message.nil? - if block_given? - message = yield - else - message = progname - progname = @progname - end - end - @logdev.write( - format_message(format_severity(severity), Time.now, progname, message)) - true - end - alias log add - - # Writes the given +msg+ to the log with no formatting; - # returns the number of characters written, - # or +nil+ if no log device exists: - # - # logger = Logger.new($stdout) - # logger << 'My message.' # => 10 - # - # Output: - # - # My message. - # - def <<(msg) - @logdev&.write(msg) - end - - # Equivalent to calling #add with severity Logger::DEBUG. - # - def debug(progname = nil, &block) - add(DEBUG, nil, progname, &block) - end - - # Equivalent to calling #add with severity Logger::INFO. - # - def info(progname = nil, &block) - add(INFO, nil, progname, &block) - end - - # Equivalent to calling #add with severity Logger::WARN. - # - def warn(progname = nil, &block) - add(WARN, nil, progname, &block) - end - - # Equivalent to calling #add with severity Logger::ERROR. - # - def error(progname = nil, &block) - add(ERROR, nil, progname, &block) - end - - # Equivalent to calling #add with severity Logger::FATAL. - # - def fatal(progname = nil, &block) - add(FATAL, nil, progname, &block) - end - - # Equivalent to calling #add with severity Logger::UNKNOWN. - # - def unknown(progname = nil, &block) - add(UNKNOWN, nil, progname, &block) - end - - # Closes the logger; returns +nil+: - # - # logger = Logger.new('t.log') - # logger.close # => nil - # logger.info('foo') # Prints "log writing failed. closed stream" - # - # Related: Logger#reopen. - def close - @logdev&.close - end - -private - - # \Severity label for logging (max 5 chars). - SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY).freeze - - def format_severity(severity) - SEV_LABEL[severity] || 'ANY' - end - - # Guarantee the existence of this ivar even when subclasses don't call the superclass constructor. - def level_override - @level_override ||= {} - end - - def format_message(severity, datetime, progname, msg) - (@formatter || @default_formatter).call(severity, datetime, progname, msg) - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb deleted file mode 100644 index 88581793f0..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/errors.rb +++ /dev/null @@ -1,9 +0,0 @@ -# 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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb deleted file mode 100644 index c634dbf34d..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/formatter.rb +++ /dev/null @@ -1,36 +0,0 @@ -# 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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb deleted file mode 100644 index 4876adf0b7..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/log_device.rb +++ /dev/null @@ -1,214 +0,0 @@ -# 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: []) - @dev = @filename = @shift_age = @shift_size = @shift_period_suffix = nil - @binmode = binmode - @reraise_write_errors = reraise_write_errors - 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' - - 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 write(message) - begin - synchronize do - if @shift_age and @dev.respond_to?(:stat) - begin - check_shift_log - rescue *@reraise_write_errors - raise - rescue - warn("log shifting failed. #{$!}") - end - end - begin - @dev.write(message) - rescue *@reraise_write_errors - raise - rescue - warn("log writing failed. #{$!}") - end - end - rescue *@reraise_write_errors - raise - rescue Exception => ignored - warn("log writing failed. #{ignored}") - end - end - - def close - begin - synchronize do - @dev.close rescue nil - end - rescue Exception - @dev.close rescue nil - end - end - - def reopen(log = nil) - # reopen the same filename if no argument, do nothing for IO - log ||= @filename if @filename - if log - synchronize do - if @filename and @dev - @dev.close rescue nil # close only file opened by Logger - @filename = nil - end - set_dev(log) - end - end - self - end - - private - - 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) - @dev.sync = true - @dev.binmode if @binmode - @filename = log - end - end - - def open_logfile(filename) - begin - File.open(filename, (File::WRONLY | File::APPEND)) - rescue Errno::ENOENT - create_logfile(filename) - end - end - - def create_logfile(filename) - begin - logdev = File.open(filename, (File::WRONLY | File::APPEND | File::CREAT | File::EXCL)) - logdev.flock(File::LOCK_EX) - logdev.sync = true - logdev.binmode if @binmode - add_log_header(logdev) - logdev.flock(File::LOCK_UN) - rescue Errno::EEXIST - # file is created by another process - logdev = open_logfile(filename) - logdev.sync = true - end - logdev - 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 - - if /mswin|mingw|cygwin/ =~ RbConfig::CONFIG['host_os'] - def lock_shift_log - yield - end - else - def lock_shift_log - retry_limit = 8 - retry_sleep = 0.1 - begin - File.open(@filename, File::WRONLY | File::APPEND) 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) - @dev.sync = true - end - end - 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 - 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 - @dev.close rescue nil - File.rename("#{@filename}", "#{@filename}.0") - @dev = create_logfile(@filename) - return true - 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 - @dev.close rescue nil - File.rename("#{@filename}", age_file) - @dev = create_logfile(@filename) - return true - end - end -end diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb deleted file mode 100644 index a0359defe3..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/period.rb +++ /dev/null @@ -1,47 +0,0 @@ -# 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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb deleted file mode 100644 index e96fb0d320..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/severity.rb +++ /dev/null @@ -1,38 +0,0 @@ -# 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/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb deleted file mode 100644 index 2a0801be63..0000000000 --- a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/logger-1.6.1/lib/logger/version.rb +++ /dev/null @@ -1,5 +0,0 @@ -# frozen_string_literal: true - -class Logger - VERSION = "1.6.1" -end