Class: Aspera::Log

Inherits:
Object
  • Object
show all
Includes:
Singleton
Defined in:
lib/aspera/log.rb

Overview

Singleton object for logging

Constant Summary collapse

LOG_TYPES =

Where logs are sent to

i[stderr stdout syslog].freeze
LEVELS =

Levels are :trace2,:trace1,:debug,:info,:warn,:error,fatal,:unknown

Logger::Severity.constants.sort{ |a, b| Logger::Severity.const_get(a) <=> Logger::Severity.const_get(b)}.map{ |c| c.downcase.to_sym}.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#dump_format ⇒ Object

Returns the value of attribute dump_format.



141
142
143
 
# File 'lib/aspera/log.rb', line 141

def dump_format
  @dump_format
end

#logger ⇒ Object (readonly)

Returns the value of attribute logger.



140
141
142
 
# File 'lib/aspera/log.rb', line 140

def logger
  @logger
end

#logger_type ⇒ Object

Returns the value of attribute logger_type.



140
141
142
 
# File 'lib/aspera/log.rb', line 140

def logger_type
  @logger_type
end

Class Method Details

.apply_colors(value, colors) ⇒ Object

Applies the provided list of string decoration (colors) to the value.



71
72
73
 
# File 'lib/aspera/log.rb', line 71

def apply_colors(value, colors)
  colors.inject(value){ |s, c| s.send(c)}
end

.caller_method ⇒ Object

Returns the last 2 containers (module/class) and method caller



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/aspera/log.rb', line 115

def caller_method
  stack = caller
  i = stack.rindex{ |line| line.include?('Logger')}
  frame = stack[i + 1] if i && stack[i + 1]
  return '???' unless frame
  # Extract the "Class::Module::Method" or "Class#method" part
  full = frame[/'([^']+)'/, 1]
  return '???' unless full
  # Split into class/module and method parts
  parts = full.split(/(::|#)/)
  # Reconstruct keeping only last two class/module names + separator + method
  if parts.include?('#')
    sep_index = parts.index('#')
    classes = parts[0...sep_index].join
    method = parts[sep_index + 1]
  else
    classes = parts[0..-2].join
    method = parts.last
  end
  class_parts = classes.split('::')
  selected_classes = class_parts.last(2).join('::')
  "#{selected_classes}.#{method}"
end

.capture_stderr ⇒ Object

Capture the output of $stderr and log it at debug level



105
106
107
108
109
110
111
112
 
# File 'lib/aspera/log.rb', line 105

def capture_stderr
  real_stderr = $stderr
  $stderr = StringIO.new
  yield if block_given?
  log.debug($stderr.string)
ensure
  $stderr = real_stderr
end

.dump(name, object = nil, level: :debug, &block) ⇒ Object

Dump object (Hash) to log using specified level



84
85
86
87
88
89
 
# File 'lib/aspera/log.rb', line 84

def dump(name, object = nil, level: :debug, &block)
  return unless instance.logger.send(:"#{level}?")
  Aspera.assert(object.nil? || block.nil?){'Use either object, or block, not both'}
  object = yield if block_given?
  instance.logger.send(level, obj_dump(name, object))
end

.log ⇒ Object

Get the logger object of singleton



76
 
# File 'lib/aspera/log.rb', line 76

def log; instance.logger; end

.obj_dump(name, object) ⇒ String 



92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/aspera/log.rb', line 92

def obj_dump(name, object)
  dump_text =
    case instance.dump_format
    when :json
      JSON.pretty_generate(object) rescue PP.pp(object, +'')
    when :ruby
      PP.pp(object, +'')
    else error_unexpected_value(instance.dump_format){'dump format'}
    end
  "#{name.to_s.green} (#{instance.dump_format})=\n#{dump_text}"
end

Instance Method Details

#formatter ⇒ Object 



166
167
168
 
# File 'lib/aspera/log.rb', line 166

def formatter
  @logger.formatter
end

#formatter=(formatter) ⇒ Object 



155
156
157
158
159
160
161
162
163
164
 
# File 'lib/aspera/log.rb', line 155

def formatter=(formatter)
  if formatter.is_a?(String)
    raise Error, "Unknown formatter #{formatter}, use one of: #{FORMATTERS.keys.join(', ')}" unless FORMATTERS.key?(formatter.to_sym)
    formatter = FORMATTERS[formatter.to_sym]
  elsif !formatter.respond_to?(:call) && !formatter.is_a?(Logger::Formatter)
    raise Error, 'Formatter must be a String, a Logger::Formatter or a Proc'
  end
  # Update formatter with password hiding
  @logger.formatter = SecretHider.instance.log_formatter(formatter)
end

#level ⇒ Symbol

Get symbol of debug level of underlying logger



172
173
174
175
 
# File 'lib/aspera/log.rb', line 172

def level
  Aspera.assert(Logger::SEVERITY_LABEL.key?(@logger.level))
  Logger::SEVERITY_LABEL[@logger.level].downcase
end

#level=(new_level) ⇒ Object

Set log level of underlying logger given symbol level



150
151
152
153
 
# File 'lib/aspera/log.rb', line 150

def level=(new_level)
  Aspera.assert_values(new_level, LEVELS)
  @logger.level = Logger::Severity.const_get(new_level.to_sym.upcase)
end

#program_name=(value) ⇒ Object 



143
144
145
146
 
# File 'lib/aspera/log.rb', line 143

def program_name=(value)
  @program_name = value
  self.logger_type = @logger_type
end