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.



138
139
140
 
# File 'lib/aspera/log.rb', line 138

def dump_format
  @dump_format
end

#logger ⇒ Object (readonly)

Returns the value of attribute logger.



137
138
139
 
# File 'lib/aspera/log.rb', line 137

def logger
  @logger
end

#logger_type ⇒ Object

Returns the value of attribute logger_type.



137
138
139
 
# File 'lib/aspera/log.rb', line 137

def logger_type
  @logger_type
end

Class Method Details

.caller_method ⇒ Object

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



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

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



102
103
104
105
106
107
108
109
 
# File 'lib/aspera/log.rb', line 102

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

Parameters:

  • name (String, Symbol) —

    Name of object dumped

  • object (Hash, nil) (defaults to: nil) —

    Data to dump

  • level (Symbol) (defaults to: :debug) —

    Debug level

  • block (Proc, nil) —

    Give computed object



81
82
83
84
85
86
 
# File 'lib/aspera/log.rb', line 81

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



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

def log; instance.logger; end

.obj_dump(name, object) ⇒ String

Returns Dump of object.

Returns:



89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/aspera/log.rb', line 89

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

.short_levl(level) ⇒ Object 



68
69
70
 
# File 'lib/aspera/log.rb', line 68

def short_levl(level)
  "#{level[0, 3]}#{level[-1]}"
end

Instance Method Details

#formatter ⇒ Object 



163
164
165
 
# File 'lib/aspera/log.rb', line 163

def formatter
  @logger.formatter
end

#formatter=(formatter) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
 
# File 'lib/aspera/log.rb', line 152

def formatter=(formatter)
  if formatter.is_a?(String)
    raise Error, "Unknown formatter #{formatter}, use one of: #{FORMATTERS.join(', ')}" unless FORMATTER_LAMBDAS.key?(formatter.to_sym)
    formatter = FORMATTER_LAMBDAS[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

Returns:

  • (Symbol) —

    One of LEVELS



169
170
171
172
 
# File 'lib/aspera/log.rb', line 169

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

Parameters:

  • new_level (Symbol) —

    One of LEVELS



147
148
149
150
 
# File 'lib/aspera/log.rb', line 147

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 



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

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