Class: Wildcloud::Logger::Logger

Inherits:
Object
  • Object
show all
Defined in:
lib/wildcloud/logger/logger.rb

Constant Summary collapse

LEVELS = 
{:debug => 10, :info => 20, :warn => 30, :error => 40, :fatal => 50}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(application = 'default', level = :debug) ⇒ Logger

Returns a new instance of Logger.



23
24
25
26
27
28
29
 
# File 'lib/wildcloud/logger/logger.rb', line 23

def initialize(application = 'default', level = :debug)
  @level = level
  @stack = []
  @base = proc { |msg|}
  @application = application
  @app = nil
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object 



87
88
89
90
 
# File 'lib/wildcloud/logger/logger.rb', line 87

def method_missing(name, *args, &block)
  return super(name, *args, &block) unless LEVELS.has_key?(name)
  log(name, args[0], args[1], args[2], &block)
end

Instance Attribute Details

#application ⇒ Object

Returns the value of attribute application.



21
22
23
 
# File 'lib/wildcloud/logger/logger.rb', line 21

def application
  @application
end

#level ⇒ Object

Returns the value of attribute level.



21
22
23
 
# File 'lib/wildcloud/logger/logger.rb', line 21

def level
  @level
end

Instance Method Details

#add(middleware, options = nil) ⇒ Object 



36
37
38
39
 
# File 'lib/wildcloud/logger/logger.rb', line 36

def add(middleware, options = nil)
  @stack << [middleware, options]
  @app = nil
end

#add_level(name, score) ⇒ Object 



59
60
61
 
# File 'lib/wildcloud/logger/logger.rb', line 59

def add_level(name, score)
  LEVELS[name] = score
end

#base=(base) ⇒ Object 



31
32
33
34
 
# File 'lib/wildcloud/logger/logger.rb', line 31

def base=(base)
  @base = base
  @app = nil
end

#build ⇒ Object 



48
49
50
51
52
53
54
55
56
57
 
# File 'lib/wildcloud/logger/logger.rb', line 48

def build
  @app = @stack.reverse.inject(@base) do |app, middleware|
    clazz, options = middleware
    if options
      clazz.new(app, options)
    else
      clazz.new(app)
    end
  end
end

#call(msg) ⇒ Object 



82
83
84
85
 
# File 'lib/wildcloud/logger/logger.rb', line 82

def call(msg)
  build unless @app
  @app.call(msg)
end

#log(level, component = nil, message = nil, options = nil) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/wildcloud/logger/logger.rb', line 67

def log(level, component=nil, message = nil, options = nil)
  return if LEVELS[level] < LEVELS[self.level]
  message = yield if block_given?
  component, message = nil, component unless message
  options ||= {}
  msg = options.merge!({
                           :level => level,
                           :application => @application,
                           :component => component,
                           :message => message,
                           :timestamp => Time.now.to_i
                       })
  call(msg)
end

#remove(middleware) ⇒ Object 



41
42
43
44
45
46
 
# File 'lib/wildcloud/logger/logger.rb', line 41

def remove(middleware)
  @stack.delete_if do |mw|
    middleware == mw[0]
  end
  @app = nil
end

#remove_level(name) ⇒ Object 



63
64
65
 
# File 'lib/wildcloud/logger/logger.rb', line 63

def remove_level(name)
  LEVELS.delete(name)
end