diff options
Diffstat (limited to 'lib/puppet/util/log.rb')
| -rw-r--r-- | lib/puppet/util/log.rb | 416 |
1 files changed, 208 insertions, 208 deletions
diff --git a/lib/puppet/util/log.rb b/lib/puppet/util/log.rb index c47aa0d6f..36a765c61 100644 --- a/lib/puppet/util/log.rb +++ b/lib/puppet/util/log.rb @@ -5,250 +5,250 @@ require 'puppet/util/classgen' # expected that that will be the most common log destination. Supports # multiple destinations, one of which is a remote server. class Puppet::Util::Log - include Puppet::Util - extend Puppet::Util::ClassGen - include Puppet::Util::Tagging + include Puppet::Util + extend Puppet::Util::ClassGen + include Puppet::Util::Tagging - @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit] - @loglevel = 2 + @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit] + @loglevel = 2 - @desttypes = {} + @desttypes = {} - # Create a new destination type. - def self.newdesttype(name, options = {}, &block) + # Create a new destination type. + def self.newdesttype(name, options = {}, &block) - dest = genclass( - name, :parent => Puppet::Util::Log::Destination, :prefix => "Dest", - :block => block, - :hash => @desttypes, + dest = genclass( + name, :parent => Puppet::Util::Log::Destination, :prefix => "Dest", + :block => block, + :hash => @desttypes, - :attributes => options - ) - dest.match(dest.name) - - dest - end + :attributes => options + ) + dest.match(dest.name) - require 'puppet/util/log/destination' - require 'puppet/util/log/destinations' + dest + end - @destinations = {} + require 'puppet/util/log/destination' + require 'puppet/util/log/destinations' - @queued = [] + @destinations = {} - class << self - include Puppet::Util - include Puppet::Util::ClassGen - - attr_reader :desttypes - end - - # Reset log to basics. Basically just flushes and closes files and - # undefs other objects. - def Log.close(destination) - if @destinations.include?(destination) - @destinations[destination].flush if @destinations[destination].respond_to?(:flush) - @destinations[destination].close if @destinations[destination].respond_to?(:close) - @destinations.delete(destination) - end - end - - def self.close_all - destinations.keys.each { |dest| - close(dest) - } - end - - # Flush any log destinations that support such operations. - def Log.flush - @destinations.each { |type, dest| - dest.flush if dest.respond_to?(:flush) - } - end - - # Create a new log message. The primary role of this method is to - # avoid creating log messages below the loglevel. - def Log.create(hash) - raise Puppet::DevError, "Logs require a level" unless hash.include?(:level) - raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level]) - @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil - end - - def Log.destinations - @destinations - end - - # Yield each valid level in turn - def Log.eachlevel - @levels.each { |level| yield level } - end + @queued = [] - # Return the current log level. - def Log.level - @levels[@loglevel] + class << self + include Puppet::Util + include Puppet::Util::ClassGen + + attr_reader :desttypes + end + + # Reset log to basics. Basically just flushes and closes files and + # undefs other objects. + def Log.close(destination) + if @destinations.include?(destination) + @destinations[destination].flush if @destinations[destination].respond_to?(:flush) + @destinations[destination].close if @destinations[destination].respond_to?(:close) + @destinations.delete(destination) end - - # Set the current log level. - def Log.level=(level) - level = level.intern unless level.is_a?(Symbol) - - raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level) - - @loglevel = @levels.index(level) + end + + def self.close_all + destinations.keys.each { |dest| + close(dest) + } + end + + # Flush any log destinations that support such operations. + def Log.flush + @destinations.each { |type, dest| + dest.flush if dest.respond_to?(:flush) + } + end + + # Create a new log message. The primary role of this method is to + # avoid creating log messages below the loglevel. + def Log.create(hash) + raise Puppet::DevError, "Logs require a level" unless hash.include?(:level) + raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level]) + @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil + end + + def Log.destinations + @destinations + end + + # Yield each valid level in turn + def Log.eachlevel + @levels.each { |level| yield level } + end + + # Return the current log level. + def Log.level + @levels[@loglevel] + end + + # Set the current log level. + def Log.level=(level) + level = level.intern unless level.is_a?(Symbol) + + raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level) + + @loglevel = @levels.index(level) + end + + def Log.levels + @levels.dup + end + + # Create a new log destination. + def Log.newdestination(dest) + # Each destination can only occur once. + if @destinations.find { |name, obj| obj.name == dest } + return end - def Log.levels - @levels.dup + name, type = @desttypes.find do |name, klass| + klass.match?(dest) end - # Create a new log destination. - def Log.newdestination(dest) - # Each destination can only occur once. - if @destinations.find { |name, obj| obj.name == dest } - return - end - - name, type = @desttypes.find do |name, klass| - klass.match?(dest) - end - - raise Puppet::DevError, "Unknown destination type #{dest}" unless type - - begin - if type.instance_method(:initialize).arity == 1 - @destinations[dest] = type.new(dest) - else - @destinations[dest] = type.new - end - flushqueue - @destinations[dest] - rescue => detail - puts detail.backtrace if Puppet[:debug] - - # If this was our only destination, then add the console back in. - newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console") - end + raise Puppet::DevError, "Unknown destination type #{dest}" unless type + + begin + if type.instance_method(:initialize).arity == 1 + @destinations[dest] = type.new(dest) + else + @destinations[dest] = type.new + end + flushqueue + @destinations[dest] + rescue => detail + puts detail.backtrace if Puppet[:debug] + + # If this was our only destination, then add the console back in. + newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console") end + end - # Route the actual message. FIXME There are lots of things this method - # should do, like caching and a bit more. It's worth noting that there's - # a potential for a loop here, if the machine somehow gets the destination set as - # itself. - def Log.newmessage(msg) - return if @levels.index(msg.level) < @loglevel + # Route the actual message. FIXME There are lots of things this method + # should do, like caching and a bit more. It's worth noting that there's + # a potential for a loop here, if the machine somehow gets the destination set as + # itself. + def Log.newmessage(msg) + return if @levels.index(msg.level) < @loglevel - queuemessage(msg) if @destinations.length == 0 - - @destinations.each do |name, dest| - threadlock(dest) do - dest.handle(msg) - end - end - end - - def Log.queuemessage(msg) - @queued.push(msg) - end + queuemessage(msg) if @destinations.length == 0 - def Log.flushqueue - return unless @destinations.size >= 1 - @queued.each do |msg| - Log.newmessage(msg) - end - @queued.clear + @destinations.each do |name, dest| + threadlock(dest) do + dest.handle(msg) + end end + end - def Log.sendlevel?(level) - @levels.index(level) >= @loglevel - end + def Log.queuemessage(msg) + @queued.push(msg) + end - # Reopen all of our logs. - def Log.reopen - Puppet.notice "Reopening log files" - types = @destinations.keys - @destinations.each { |type, dest| - dest.close if dest.respond_to?(:close) - } - @destinations.clear - # We need to make sure we always end up with some kind of destination - begin - types.each { |type| - Log.newdestination(type) - } - rescue => detail - if @destinations.empty? - Log.newdestination(:syslog) - Puppet.err detail.to_s - end - end + def Log.flushqueue + return unless @destinations.size >= 1 + @queued.each do |msg| + Log.newmessage(msg) end - - # Is the passed level a valid log level? - def self.validlevel?(level) - @levels.include?(level) + @queued.clear + end + + def Log.sendlevel?(level) + @levels.index(level) >= @loglevel + end + + # Reopen all of our logs. + def Log.reopen + Puppet.notice "Reopening log files" + types = @destinations.keys + @destinations.each { |type, dest| + dest.close if dest.respond_to?(:close) + } + @destinations.clear + # We need to make sure we always end up with some kind of destination + begin + types.each { |type| + Log.newdestination(type) + } + rescue => detail + if @destinations.empty? + Log.newdestination(:syslog) + Puppet.err detail.to_s + end end + end - attr_accessor :time, :remote, :file, :line, :version, :source - attr_reader :level, :message - - def initialize(args) - self.level = args[:level] - self.message = args[:message] - self.source = args[:source] || "Puppet" - - @time = Time.now + # Is the passed level a valid log level? + def self.validlevel?(level) + @levels.include?(level) + end - if tags = args[:tags] - tags.each { |t| self.tag(t) } - end + attr_accessor :time, :remote, :file, :line, :version, :source + attr_reader :level, :message - [:file, :line, :version].each do |attr| - next unless value = args[attr] - send(attr.to_s + "=", value) - end + def initialize(args) + self.level = args[:level] + self.message = args[:message] + self.source = args[:source] || "Puppet" - Log.newmessage(self) - end + @time = Time.now - def message=(msg) - raise ArgumentError, "Puppet::Util::Log requires a message" unless msg - @message = msg.to_s + if tags = args[:tags] + tags.each { |t| self.tag(t) } end - def level=(level) - raise ArgumentError, "Puppet::Util::Log requires a log level" unless level - @level = level.to_sym - raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level) - - # Tag myself with my log level - tag(level) + [:file, :line, :version].each do |attr| + next unless value = args[attr] + send(attr.to_s + "=", value) end - # If they pass a source in to us, we make sure it is a string, and - # we retrieve any tags we can. - def source=(source) - if source.respond_to?(:source_descriptors) - descriptors = source.source_descriptors - @source = descriptors[:path] - - descriptors[:tags].each { |t| tag(t) } - - [:file, :line, :version].each do |param| - next unless descriptors[param] - send(param.to_s + "=", descriptors[param]) - end - else - @source = source.to_s - end + Log.newmessage(self) + end + + def message=(msg) + raise ArgumentError, "Puppet::Util::Log requires a message" unless msg + @message = msg.to_s + end + + def level=(level) + raise ArgumentError, "Puppet::Util::Log requires a log level" unless level + @level = level.to_sym + raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level) + + # Tag myself with my log level + tag(level) + end + + # If they pass a source in to us, we make sure it is a string, and + # we retrieve any tags we can. + def source=(source) + if source.respond_to?(:source_descriptors) + descriptors = source.source_descriptors + @source = descriptors[:path] + + descriptors[:tags].each { |t| tag(t) } + + [:file, :line, :version].each do |param| + next unless descriptors[param] + send(param.to_s + "=", descriptors[param]) + end + else + @source = source.to_s end + end - def to_report - "#{time} #{source} (#{level}): #{to_s}" - end + def to_report + "#{time} #{source} (#{level}): #{to_s}" + end - def to_s - message - end + def to_s + message + end end # This is for backward compatibility from when we changed the constant to Puppet::Util::Log |