Module: Log

Extended by:
Term::ANSIColor
Defined in:
lib/rbbt/util/log.rb,
lib/rbbt/util/log/progress.rb,
lib/rbbt/util/log/progress/util.rb,
lib/rbbt/util/log/progress/report.rb

Defined Under Namespace

Classes: ProgressBar

Constant Summary collapse

LOG_MUTEX =

ToDo: I’m not sure if using a Mutex here really gives troubles in CPU concurrency

MockMutex.new
SEVERITY_COLOR =

.collect{|e| “033[#{e}”}

[reset, cyan, green, magenta, blue, yellow, red]
HIGHLIGHT = 
"\033[1m"
LAST = 
"log"

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.logfile(file = nil) ⇒ Object

Returns the value of attribute logfile.



72
73
74
 
# File 'lib/rbbt/util/log.rb', line 72

def logfile
  @logfile
end

.nocolor ⇒ Object

Returns the value of attribute nocolor.



72
73
74
 
# File 'lib/rbbt/util/log.rb', line 72

def nocolor
  @nocolor
end

.severity ⇒ Object

Returns the value of attribute severity.



72
73
74
 
# File 'lib/rbbt/util/log.rb', line 72

def severity
  @severity
end

.tty_size ⇒ Object

Returns the value of attribute tty_size.



72
73
74
 
# File 'lib/rbbt/util/log.rb', line 72

def tty_size
  @tty_size
end

Class Method Details

._ignore_stderr ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/rbbt/util/log.rb', line 37

def self._ignore_stderr
  backup_stderr = STDERR.dup
  File.open('/dev/null', 'w') do |f|
      STDERR.reopen(f)
      begin
        yield
      ensure
        STDERR.reopen backup_stderr
        backup_stderr.close
      end
  end
end

.clear_line(out = STDOUT) ⇒ Object 



148
149
150
 
# File 'lib/rbbt/util/log.rb', line 148

def self.clear_line(out = STDOUT)
  out.puts Log.return_line << " " * (Log.tty_size || 80) << Log.return_line unless nocolor
end

.color(severity, str = nil, reset = false) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/rbbt/util/log.rb', line 124

def self.color(severity, str = nil, reset = false)
  return str.dup || "" if nocolor 
  color = reset ? Term::ANSIColor.reset : ""
  color << SEVERITY_COLOR[severity] if Integer === severity
  color << Term::ANSIColor.send(severity) if Symbol === severity and Term::ANSIColor.respond_to? severity 
  if str.nil?
    color
  else
    color + str.to_s + self.color(0)
  end
end

.color_stack(stack) ⇒ Object 



250
251
252
253
254
255
256
257
 
# File 'lib/rbbt/util/log.rb', line 250

def self.color_stack(stack)
  stack.collect do |line|
    line = line.sub('`',"'")
    color = :green if line =~ /workflow/
    color = :blue if line =~ /rbbt-/
    Log.color color, line
  end
end

.debug(message = nil, &block) ⇒ Object 



210
211
212
 
# File 'lib/rbbt/util/log.rb', line 210

def self.debug(message = nil, &block)
  log(message, DEBUG, &block)
end

.deprecated(m) ⇒ Object 



244
245
246
247
248
 
# File 'lib/rbbt/util/log.rb', line 244

def self.deprecated(m)
  stack = caller
  warn("DEPRECATED: " << Log.last_caller(stack))
  warn("* " << (m || "").to_s)
end

.down_lines(num = 1) ⇒ Object 



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

def self.down_lines(num = 1)
  "\033[#{num+1}E"
end

.error(message = nil, &block) ⇒ Object 



234
235
236
 
# File 'lib/rbbt/util/log.rb', line 234

def self.error(message = nil, &block)
  log(message, ERROR, &block)
end

.exception(e) ⇒ Object 



238
239
240
241
242
 
# File 'lib/rbbt/util/log.rb', line 238

def self.exception(e)
  stack = caller
  error([e.class.to_s, e.message].compact * ": " )
  error("BACKTRACE [#{Process.pid}]: " << Log.last_caller(stack) << "\n" + color_stack(e.backtrace)*"\n")
end

.get_level(level) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/rbbt/util/log.rb', line 56

def self.get_level(level)
  case level
  when Numeric
    level.to_i
  when String
    begin
      Log.const_get(level.upcase)
    rescue
      Log.exception $!
    end
  when Symbol
    get_level(level.to_s)
  end || 0
end

.high(message = nil, &block) ⇒ Object 



222
223
224
 
# File 'lib/rbbt/util/log.rb', line 222

def self.high(message = nil, &block)
  log(message, HIGH, &block)
end

.highlight(str = nil) ⇒ Object 



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

def self.highlight(str = nil)
  if str.nil?
    return "" if nocolor
    HIGHLIGHT
  else
    return str if nocolor
    HIGHLIGHT + str + color(0)
  end
end

.ignore_stderr(&block) ⇒ Object 



50
51
52
53
54
 
# File 'lib/rbbt/util/log.rb', line 50

def self.ignore_stderr(&block)
  LOG_MUTEX.synchronize do
    _ignore_stderr &block
  end
end

.info(message = nil, &block) ⇒ Object 



226
227
228
 
# File 'lib/rbbt/util/log.rb', line 226

def self.info(message = nil, &block)
  log(message, INFO, &block)
end

.last_caller(stack) ⇒ Object 



27
28
29
30
31
32
33
34
35
 
# File 'lib/rbbt/util/log.rb', line 27

def self.last_caller(stack)
  line = nil
  pos ||= 0
  while line.nil? or line =~ /util\/log\.rb/ and stack.any? 
    line = stack.shift 
  end
  line ||= caller.first
  line.gsub('`', "'")
end

.log(message = nil, severity = MEDIUM, &block) ⇒ Object 



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/rbbt/util/log.rb', line 163

def self.log(message = nil, severity = MEDIUM, &block)
  return if severity < self.severity 
  message ||= block.call if block_given?
  return if message.nil?

  time = Time.now.strftime("%m/%d/%y-%H:%M:%S.%L")

  sev_str = severity.to_s

  prefix = time << color(severity) << "["  << sev_str << "]" << color(0)
  message = "" << highlight << message << color(0) if severity >= INFO
  str = prefix << " " << message.to_s

  LOG_MUTEX.synchronize do
    STDERR.puts str
    Log::LAST.replace "log"
    logfile.puts str unless logfile.nil?
    nil
  end
end

.log_obj_fingerprint(obj, level, file = $stdout) ⇒ Object 



197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/rbbt/util/log.rb', line 197

def self.log_obj_fingerprint(obj, level, file = $stdout)
  stack = caller

  line = Log.last_caller stack

  level = Log.get_level level
  name = Log::SEVERITY_NAMES[level] + ": "
  Log.log Log.color(level, name, true) << line, level
  Log.log "", level
  Log.log Log.color(level, "=> ", true) << Misc.fingerprint(obj), level
  Log.log "", level
end

.log_obj_inspect(obj, level, file = $stdout) ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/rbbt/util/log.rb', line 184

def self.log_obj_inspect(obj, level, file = $stdout)
  stack = caller

  line = Log.last_caller stack

  level = Log.get_level level
  name = Log::SEVERITY_NAMES[level] + ": "
  Log.log Log.color(level, name, true) << line, level
  Log.log "", level
  Log.log Log.color(level, "=> ", true) << obj.inspect, level
  Log.log "", level
end

.low(message = nil, &block) ⇒ Object 



214
215
216
 
# File 'lib/rbbt/util/log.rb', line 214

def self.low(message = nil, &block)
  log(message, LOW, &block)
end

.medium(message = nil, &block) ⇒ Object 



218
219
220
 
# File 'lib/rbbt/util/log.rb', line 218

def self.medium(message = nil, &block)
  log(message, MEDIUM, &block)
end

.reset_color ⇒ Object 



120
121
122
 
# File 'lib/rbbt/util/log.rb', line 120

def self.reset_color
  reset
end

.return_line ⇒ Object 



144
145
146
 
# File 'lib/rbbt/util/log.rb', line 144

def self.return_line
  nocolor ? "" : "\033[1A"
end

.stack(stack) ⇒ Object 



265
266
267
268
269
270
271
272
273
 
# File 'lib/rbbt/util/log.rb', line 265

def self.stack(stack)
  LOG_MUTEX.synchronize do

    STDERR.puts Log.color :magenta, "Stack trace [#{Process.pid}]: " << Log.last_caller(caller)
    color_stack(stack).each do |line|
      STDERR.puts line
    end
  end
end

.tsv(tsv) ⇒ Object 



259
260
261
262
263
 
# File 'lib/rbbt/util/log.rb', line 259

def self.tsv(tsv)
  STDERR.puts Log.color :magenta, "TSV log: " << Log.last_caller(caller).gsub('`',"'")
  STDERR.puts Log.color(:blue, "=> "<< Misc.fingerprint(tsv), true) 
  STDERR.puts Log.color(:cyan, "=> " << tsv.summary)
end

.uncolor(str) ⇒ Object 



116
117
118
 
# File 'lib/rbbt/util/log.rb', line 116

def self.uncolor(str)
  Term::ANSIColor.uncolor(str)
end

.up_lines(num = 1) ⇒ Object 



136
137
138
 
# File 'lib/rbbt/util/log.rb', line 136

def self.up_lines(num = 1)
  "\033[#{num+1}F\033[2K"
end

.warn(message = nil, &block) ⇒ Object 



230
231
232
 
# File 'lib/rbbt/util/log.rb', line 230

def self.warn(message = nil, &block)
  log(message, WARN, &block)
end

.with_severity(level) ⇒ Object 



86
87
88
89
90
91
92
93
94
 
# File 'lib/rbbt/util/log.rb', line 86

def self.with_severity(level)
  orig = Log.severity
  begin
    Log.severity = level
    yield
  ensure
    Log.severity = orig
  end
end