class Loggability::Override

A class which encapsulates the logic and data of temporarily overriding one or more aspects of logging for the execution of one or more blocks of code.

It's not meant to be used directly, but via one of the override aggregate methods on Loggability:

Attributes

overridden_settings[R]

The original settings preserved by the Override during a call to call, keyed by the logger they belong to.

settings[R]

The Override's settings Hash (the settings that will be applied during an overridden call).

Public Class Methods

formatted_with( new_formatter, &block ) click to toggle source

Set up an Override with its logging formatter set to formatter. If called with a block, call call immediately on the Override with the block and return the result of that instead.

# File lib/loggability/override.rb, line 40
def self::formatted_with( new_formatter, &block )
        return self.new( formatter: new_formatter, &block )
end
new( settings={} ) click to toggle source

Create a new Override with the specified settings that will be applied during a call to call, and then reverted when call returns. Valid settings are:

:level

Set the level of all Loggers to the value.

:logdev

Set the destination log device of all Loggers to the value.

:formatter

Set the formatter for all Loggers to the value (a Loggability::Formatter).

Calls superclass method
# File lib/loggability/override.rb, line 56
def initialize( settings={} )
        super()

        @settings = settings
        @overridden_settings = {}
end
outputting_to( new_destination, &block ) click to toggle source

Set up an Override with its logging output set to new_destination. If called with a block, call call immediately on the Override with the block and return the result of that instead.

# File lib/loggability/override.rb, line 32
def self::outputting_to( new_destination, &block )
        return self.new( logdev: new_destination, &block )
end
with_level( new_level, &block ) click to toggle source

Set up an Override with its logging level set to newlevel. If called with a block, call call immediately on the Override with the block and return the result of that instead.

# File lib/loggability/override.rb, line 24
def self::with_level( new_level, &block )
        return self.new( level: new_level, &block )
end

Public Instance Methods

call() { || ... } click to toggle source

Call the provided block with configured overrides applied, and then restore the previous settings before control is returned.

# File lib/loggability/override.rb, line 87
def call
        self.apply_overrides
        yield
ensure
        self.restore_overridden_settings
end
formatted_with( new_formatter, &block ) click to toggle source

Return a clone of the receiving Override with its logging formatter set to formatter.

# File lib/loggability/override.rb, line 115
def formatted_with( new_formatter, &block )
        return self.clone_with( formatter: new_formatter, &block )
end
initialize_copy( original ) click to toggle source

Copy constructor – make copies of the internal data structures when duplicated.

# File lib/loggability/override.rb, line 66
def initialize_copy( original )
        @settings = original.settings.dup
        @overridden_settings = {}
end
inspect() click to toggle source

Return the object as a human-readable string suitable for debugging.

# File lib/loggability/override.rb, line 121
def inspect
        return "#<%p:%#016x formatter: %s, level: %s, output: %s>" % [
                self.class,
                self.object_id * 2,
                self.settings[:formatter] || '-',
                self.settings[:level] || '-',
                self.settings[:logdev] ? self.settings[:logdev].class : '-',
        ]
end
outputting_to( new_destination, &block ) click to toggle source

Return a clone of the receiving Override with its logging output set to new_destination.

# File lib/loggability/override.rb, line 108
def outputting_to( new_destination, &block )
        return self.clone_with( logdev: new_destination, &block )
end
with_level( new_level, &block ) click to toggle source

Return a clone of the receiving Override with its logging level set to newlevel.

# File lib/loggability/override.rb, line 101
def with_level( new_level, &block )
        return self.clone_with( level: new_level, &block )
end

Protected Instance Methods

apply_overrides() click to toggle source

Apply any configured overrides to all loggers.

# File lib/loggability/override.rb, line 150
def apply_overrides
        self.synchronize do
                raise LocalJumpError, "can't be called re-entrantly" unless
                        @overridden_settings.empty?
                @overridden_settings = self.gather_current_settings
        end

        Loggability.log_hosts.each do |key, host|
                host.logger.restore_settings( self.settings )
        end
end
clone_with( new_settings, &block ) click to toggle source

Return a clone that has been modified with the specified new_settings.

# File lib/loggability/override.rb, line 137
def clone_with( new_settings, &block )
        newobj = self.dup
        newobj.settings.merge!( new_settings )

        if block
                return newobj.call( &block )
        else
                return newobj
        end
end
gather_current_settings() click to toggle source

Return a Hash of Loggers with the settings they currently have.

# File lib/loggability/override.rb, line 164
def gather_current_settings
        return Loggability.log_hosts.values.each_with_object( {} ) do |host, hash|
                hash[ host ] = host.logger.settings
        end
end
restore_overridden_settings() click to toggle source

Restore the last settings saved by apply_overrides to their corresponding loggers.

# File lib/loggability/override.rb, line 173
def restore_overridden_settings
        @overridden_settings.each do |host, settings|
                host.logger.restore_settings( settings )
        end
        @overridden_settings.clear
end