cabin 0.4.2 → 0.4.3

data/examples/sample.rb

@@ -1,6 +1,5 @@
 require "rubygems"
 require "cabin"
-require "logger"
 
 # Logging::... is something I'm implemented and experimenting with.
 @logger = Cabin::Channel.new
@@ -8,9 +7,8 @@ require "logger"
 # A logging channel can have any number of subscribers.
 # Any subscriber is simply expected to respond to '<<' and take a single
 # argument (the event)
-# Special case of stdlib Logger instances that are wrapped smartly to 
-# log JSON and call the right Logger method (Logger#info, etc).
-@logger.subscribe(Logger.new(STDOUT))
+# Special case handling of stdlib Logger and IO objects comes for free, though.
+@logger.subscribe(STDOUT)
 
 # You can store arbitrary key-value pairs in the logging channel. 
 # These are emitted with every event.

data/lib/cabin/channel.rb

@@ -1,6 +1,7 @@
 require "cabin/mixins/logger"
+require "cabin/mixins/timestamp"
+require "cabin/mixins/timer"
 require "cabin/namespace"
-require "cabin/timer"
 require "cabin/context"
 require "cabin/outputs/stdlib-logger"
 require "cabin/outputs/io"
@@ -45,26 +46,42 @@ require "logger"
 #     I, [2011-10-11T01:00:57.993575 #1209]  INFO -- : {:timestamp=>"2011-10-11T01:00:57.993517-0700", :message=>"Done in foo", :level=>:info}
 #
 class Cabin::Channel
+  class << self
+    # Get a channel for a given identifier. If this identifier has never been
+    # used, a new channel is created for it.
+    # The default identifier is the application executable name.
+    #
+    # This is useful for using the same Cabin::Channel across your
+    # entire application.
+    def get(identifier=$0)
+      @channels ||= Hash.new { |h,k| h[k] = Cabin::Channel.new }
+      return @channels[identifier]
+    end # def Cabin::Channel.get
+
+    # Get a list of filters included in this class.
+    def filters
+      @filters ||= []
+    end # def Cabin::Channel.filters
+    
+    # Register a new filter. The block is passed the event. It is expected to
+    # modify that event or otherwise do nothing.
+    def filter(&block)
+      @filters ||= []
+      @filters << block
+    end
+  end # class << self
+
   include Cabin::Mixins::Logger
+  include Cabin::Mixins::Timestamp
+  include Cabin::Mixins::Timer
 
   # All channels come with a metrics provider.
   attr_accessor :metrics
-
-  # Get a channel for a given identifier. If this identifier has never been
-  # used, a new channel is created for it.
-  # The default identifier is the application executable name.
-  #
-  # This is useful for using the same Cabin::Channel across your
-  # entire application.
-  public
-  def self.get(identifier=$0)
-    @channels ||= Hash.new { |h,k| h[k] = Cabin::Channel.new }
-    return @channels[identifier]
-  end # def Cabin::Channel.get
+  
+  private
 
   # Create a new logging channel.
   # The default log level is 'info'
-  public
   def initialize
     @outputs = []
     @data = {}
@@ -76,7 +93,6 @@ class Cabin::Channel
   # Subscribe a new input
   # New events will be sent to the subscriber using the '<<' method
   #   foo << event
-  public
   def subscribe(output)
     # Wrap ruby stdlib Logger if given.
     if output.is_a?(::Logger)
@@ -90,19 +106,16 @@ class Cabin::Channel
   end # def subscribe
  
   # Set some contextual map value
-  public
   def []=(key, value)
     @data[key] = value
   end # def []= 
 
   # Get a context value by name.
-  public
   def [](key)
     @data[key]
   end # def []
 
   # Remove a context value by name.
-  public
   def remove(key)
     @data.delete(key)
   end # def remove
@@ -114,52 +127,36 @@ class Cabin::Channel
   #
   # A special key :timestamp is set at the time of this method call. The value
   # is a string ISO8601 timestamp with microsecond precision.
-  public
   def publish(data)
-    event = {
-      :timestamp => Time.now.strftime("%Y-%m-%dT%H:%M:%S.%6N%z")
-    }
-    event.merge!(@data)
-    # TODO(sissel): need to refactor string->hash shoving.
+    event = {}
+    event.merge!(@data) # Merge any logger context
+
     if data.is_a?(String)
       event[:message] = data
     else
       event.merge!(data)
     end
 
+    self.class.filters.each do |filter|
+      filter.call(event)
+    end
+
     @outputs.each do |out|
       out << event
     end
   end # def publish
 
-  # Start timing something.
-  # Returns an instance of Cabin::Timer bound to this Cabin::Channel.
-  # To stop the timer and immediately emit the result to this channel, invoke
-  # the Cabin::Timer#stop method.
-  public
-  def time(data, &block)
-    # TODO(sissel): need to refactor string->hash shoving.
-    if data.is_a?(String)
-      data = { :message => data }
-    end
-
-    timer = Cabin::Timer.new do |duration|
-      # TODO(sissel): Document this field
-      data[:duration] = duration
-      publish(data)
-    end
-
-    if block_given?
-      block.call
-      return timer.stop
-    else
-      return timer
-    end
-  end # def time
-
-  public
   def context
     ctx = Cabin::Context.new(self)
     return ctx
   end # def context
+
+  def dataify(data)
+    if data.is_a?(String)
+      data = { :message => data }
+    end
+    return data
+  end # def dataify
+
+  public(:initialize, :context, :subscribe, :[]=, :[], :remove, :publish, :time, :context)
 end # class Cabin::Channel

data/lib/cabin/mixins/CAPSLOCK.rb

@@ -2,23 +2,15 @@ require "cabin/namespace"
 
 # ALL CAPS MEANS SERIOUS BUSINESS
 module Cabin::Mixins::CAPSLOCK
-  def log(level, message, data={})
-    if message.is_a?(Hash)
-      data.merge!(message)
-    else
-      data[:message] = message
+  def self.extended(instance)
+    self.included(instance.class)
+  end
+  def self.included(klass)
+    klass.filter do |event|
+      # CAPITALIZE ALL THE STRINGS
+      event.each do |key, value|
+        event[key] = value.upcase if value.respond_to?(:upcase)
+      end
     end
-
-    # CAPITALIZE ALL THE STRINGS
-    data.each do |key, value|
-      value.upcase! if value.respond_to?(:upcase!)
-    end
-
-    # Add extra debugging bits (file, line, method) if level is debug.
-    debugharder(caller.collect { |c| c.upcase }, data) if @level == :debug
-
-    data[:level] = level.upcase
-
-    publish(data)
-  end # def log
-end # module Cabin::Mixins::CAPSLOCK
+  end
+end # MODULE CABIN::MIXINS::CAPSLOCK

data/lib/cabin/mixins/colors.rb

@@ -0,0 +1,24 @@
+require "cabin/namespace"
+require "cabin/mixins/logger"
+
+# Colorful logging.
+module Cabin::Mixins::Colors
+  def included(klass)
+    klass.extend(Cabin::Mixins::Logger)
+  end
+
+  COLORS = [ :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white ]
+
+  COLORS.each do |color|
+    # define the color first
+    define_method(color) do |message, data={}|
+      log(message, data.merge(:color => color))
+    end
+
+    # Exclamation marks mean bold. You should probably use bold all the time
+    # because it's awesome.
+    define_method("#{color}!".to_sym) do |message, data={}|
+      log(message, data.merge(:color => color, :bold => true))
+    end
+  end
+end # module Cabin::Mixins::Colors

data/lib/cabin/mixins/logger.rb

@@ -12,6 +12,8 @@ module Cabin::Mixins::Logger
     :debug => 4
   }
 
+  BACKTRACE_RE = /([^:]+):([0-9]+):in `(.*)'/
+
   def level=(value)
     if value.respond_to?(:downcase)
       @level = value.downcase.to_sym
@@ -59,7 +61,7 @@ module Cabin::Mixins::Logger
                                   "a #{data.class.name}, I require a Hash.")
       end
 
-      log(level, message, data) if send(predicate)
+      log_with_level(level, message, data) if send(predicate)
     end
 
     # def info?, def warn? ...
@@ -71,26 +73,40 @@ module Cabin::Mixins::Logger
   end # end defining level-based log methods
 
   private
-  def log(level, message, data={})
+  def log_with_level(level, message, data={})
     # Invoke 'info?' etc to ask if we should act.
-    if message.is_a?(Hash)
-      data.merge!(message)
-    else
-      data[:message] = message
+    data[:level] = level
+    _log(message, data)
+  end # def log_with_level
+
+  def log(message, data={})
+    _log(message, data)
+  end
+
+  def _log(message, data={})
+    case message
+      when Hash
+        data.merge!(message)
+      when Exception
+        # message is an exception
+        data[:message] = message.to_s
+        data[:exception] = message.class
+        data[:backtrace] = message.backtrace
+      else
+        data[:message] = message
     end
 
     # Add extra debugging bits (file, line, method) if level is debug.
-    debugharder(caller, data) if @level == :debug
+    debugharder(caller[2], data) if @level == :debug
 
-    data[:level] = level
     publish(data)
   end # def log
 
   # This method is used to pull useful information about the caller
   # of the logging method such as the caller's file, method, and line number.
-  private
-  def debugharder(callstack, data)
-    path, line, method = callstack[1].split(/(?::in `|:|')/)
+  def debugharder(callinfo, data)
+    m = BACKTRACE_RE.match(callinfo)
+    path, line, method = m[1..3]
     whence = $:.detect { |p| path.start_with?(p) }
     if whence
       # Remove the RUBYLIB path portion of the full file name 
@@ -104,4 +120,6 @@ module Cabin::Mixins::Logger
     data[:line] = line
     data[:method] = method
   end # def debugharder
+
+  public(:log)
 end # module Cabin::Mixins::Logger

data/lib/cabin/mixins/timer.rb

@@ -0,0 +1,25 @@
+require "cabin/namespace"
+require "cabin/timer"
+
+module Cabin::Mixins::Timer
+  # Start timing something.
+  # Returns an instance of Cabin::Timer bound to this Cabin::Channel.
+  # To stop the timer and immediately emit the result to this channel, invoke
+  # the Cabin::Timer#stop method.
+  def time(data, &block)
+    # TODO(sissel): need to refactor string->hash shoving.
+    data = dataify(data)
+
+    timer = Cabin::Timer.new do |duration|
+      data[:duration] = duration
+      publish(data)
+    end
+
+    if block_given?
+      block.call
+      return timer.stop
+    else
+      return timer
+    end
+  end # def time
+end # module Cabin::Mixins::Timer

data/lib/cabin/mixins/timestamp.rb

@@ -0,0 +1,13 @@
+require "cabin/namespace"
+
+# Timestamp events before publishing.
+module Cabin::Mixins::Timestamp
+  def self.extended(instance)
+    self.included(instance.class)
+  end
+  def self.included(klass)
+    klass.filter do |event|
+      event[:timestamp] = Time.now.strftime("%Y-%m-%dT%H:%M:%S.%6N%z")
+    end
+  end
+end

data/lib/cabin/outputs/io.rb

@@ -3,35 +3,84 @@ require "json"
 
 # Wrap IO objects with a reasonable log output. 
 #
-# If the IO instance is attached to a TTY, the output will try to be a bit more
-# human-friendly in this format:
+# If the IO is *not* attached to a tty (io#tty? returns false), then
+# the event will be written in json format terminated by a newline:
 #
-#     message {json data}
+#     { "timestamp": ..., "message": message, ... }
 #
-# If the IO instance is not attached to a TTY, the output will be the JSON
-# representation of the event:
+# If the IO is attached to a TTY, there are # human-friendly in this format:
 #
-#     { "timestamp": ..., "message": message, ... }
+#     message {json data}
+#
+# Additionally, colorized output may be available. If the event has :level,
+# :color, or :bold. Any of the Cabin::Mixins::Logger methods (info, error, etc)
+# will result in colored output. See the LEVELMAP for the mapping of levels
+# to colors.
 class Cabin::Outputs::IO
-  public
+  # Mapping of color/style names to ANSI control values
+  CODEMAP = {
+    :normal => 0,
+    :bold => 1,
+    :black => 30,
+    :red => 31,
+    :green => 32,
+    :yellow => 33,
+    :blue => 34,
+    :magenta => 35,
+    :cyan => 36,
+    :white => 37
+  }
+
+  # Map of log levels to colors
+  LEVELMAP = {
+    :fatal => :red,
+    :error => :red,
+    :warn => :yellow,
+    :info => :green, # default color
+    :debug => :cyan,
+  }
+
   def initialize(io)
     @io = io
   end # def initialize
 
   # Receive an event
-  public
   def <<(event)
-    if @io.tty?
-      data = event.clone
-      # delete things from the 'data' portion that's not really data.
-      data.delete(:message)
-      data.delete(:timestamp)
-      message = "#{event[:message]} #{data.to_json}"
-
-      @io.puts(message)
-      @io.flush if @io.tty?
-    else
+    if !@io.tty?
       @io.puts(event.to_json)
+    else
+      tty_write(event)
     end
   end # def <<
+
+  private
+  def tty_write(event)
+    # The io is attached to a tty, so make pretty colors.
+    # delete things from the 'data' portion that's not really data.
+    data = event.clone
+    data.delete(:message)
+    data.delete(:timestamp)
+
+    color = data.delete(:color)
+    # :bold is expected to be truthy
+    bold = data.delete(:bold) ? :bold : nil
+
+    # Make 'error' and other log levels have color
+    if color.nil? and data[:level]
+      color = LEVELMAP[data[:level]]
+    end
+
+    if data.empty?
+      message = [event[:message]]
+    else
+      message = ["#{event[:message]} #{data.to_json}"]
+    end
+    message.unshift("\e[#{CODEMAP[color.to_sym]}m") if !color.nil?
+    message.unshift("\e[#{CODEMAP[bold]}m") if !bold.nil?
+    message.push("\e[#{CODEMAP[:normal]}m") if !(bold.nil? and color.nil?)
+    @io.puts(message.join(""))
+    @io.flush
+  end # def <<
+
+  public(:initialize, :<<)
 end # class Cabin::Outputs::StdlibLogger

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cabin
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-29 00:00:00.000000000 Z
+date: 2012-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &17771920 !ruby/object:Gem::Requirement
+  requirement: &17116580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *17771920
+  version_requirements: *17116580
 description: This is an experiment to try and make logging more flexible and more
   consumable. Plain text logs are bullshit, let's emit structured and contextual logs.
   Metrics, too!
@@ -40,8 +40,11 @@ files:
 - lib/cabin/publisher.rb
 - lib/cabin/channel.rb
 - lib/cabin/mixins/logger.rb
+- lib/cabin/mixins/colors.rb
 - lib/cabin/mixins/dragons.rb
 - lib/cabin/mixins/CAPSLOCK.rb
+- lib/cabin/mixins/timer.rb
+- lib/cabin/mixins/timestamp.rb
 - lib/cabin/timer.rb
 - lib/cabin/metric.rb
 - lib/cabin/metrics.rb