steno 0.0.3

data/lib/steno/log_level.rb

@@ -0,0 +1,24 @@
+module Steno
+end
+
+class Steno::LogLevel
+  include Comparable
+
+  attr_reader :name
+  attr_reader :priority
+
+  # @param [String]  name      "info", "debug", etc.
+  # @param [Integer] priority  "info" > "debug", etc.
+  def initialize(name, priority)
+    @name = name
+    @priority = priority
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+  def <=>(other)
+    @priority <=> other.priority
+  end
+end

data/lib/steno/logger.rb

@@ -0,0 +1,177 @@
+require "thread"
+
+require "steno/errors"
+require "steno/log_level"
+
+module Steno
+end
+
+class Steno::Logger
+  LEVELS = {
+    :off    => Steno::LogLevel.new(:off,     0),
+    :fatal  => Steno::LogLevel.new(:fatal,   1),
+    :error  => Steno::LogLevel.new(:error,   5),
+    :warn   => Steno::LogLevel.new(:warn,   10),
+    :info   => Steno::LogLevel.new(:info,   15),
+    :debug  => Steno::LogLevel.new(:debug,  16),
+    :debug1 => Steno::LogLevel.new(:debug1, 17),
+    :debug2 => Steno::LogLevel.new(:debug2, 18),
+    :all    => Steno::LogLevel.new(:all,    30),
+  }
+
+  class << self
+    # The following helpers are used to create a new scope for binding the log
+    # level.
+
+    def define_log_method(name)
+      define_method(name) { |*args, &blk| log(name, *args, &blk) }
+    end
+
+    def define_logf_method(name)
+      define_method(name.to_s + "f") { |fmt, *args| log(name, fmt % args) }
+    end
+
+    def define_level_active_predicate(name)
+      define_method(name.to_s + "?") { level_active?(name) }
+    end
+
+    def lookup_level(name)
+      level = LEVELS[name]
+
+      if level.nil?
+        raise Steno::Error.new("Unknown level: #{name}")
+      end
+
+      level
+    end
+  end
+
+  # This is magic, however, it's vastly simpler than declaring each method
+  # manually.
+  LEVELS.each do |name, _|
+    # Define #debug, for example
+    define_log_method(name)
+
+    # Define #debugf, for example
+    define_logf_method(name)
+
+    # Define #debug?, for example. These are provided to ensure compatibility
+    # with Ruby's standard library Logger class.
+    define_level_active_predicate(name)
+  end
+
+  attr_reader :name
+
+  # @param [String] name The logger name.
+  # @param [Array<Steno::Sink::Base>] sinks
+  # @param [Hash] opts
+  # @option opts [Symbol] :level  The minimum level for which this logger will
+  #         emit log records. Defaults to :info.
+  # @option opts [Steno::Context] :context
+  def initialize(name, sinks, opts = {})
+    @name           = name
+    @min_level      = self.class.lookup_level(opts[:level] || :info)
+    @min_level_lock = Mutex.new
+    @sinks          = sinks
+    @context        = opts[:context] || Steno::Context::Null.new
+  end
+
+  # Sets the minimum level for which records will be added to sinks.
+  #
+  # @param [Symbol] level_name  The level name
+  #
+  # @return [nil]
+  def level=(level_name)
+    level = self.class.lookup_level(level_name)
+
+    @min_level_lock.synchronize { @min_level = level }
+
+    nil
+  end
+
+  # Returns the name of the current log level
+  #
+  # @return [Symbol]
+  def level
+    @min_level_lock.synchronize { @min_level.name }
+  end
+
+  # Returns whether or not records for the given level would be forwarded to
+  # sinks.
+  #
+  # @param [Symbol] level_name
+  #
+  # @return [true || false]
+  def level_active?(level_name)
+    level = self.class.lookup_level(level_name)
+
+    @min_level_lock.synchronize { level <= @min_level }
+  end
+
+  # Convenience method for logging an exception, along with its backtrace.
+  #
+  # @param [Exception] ex
+
+  # @return [nil]
+  def log_exception(ex, user_data = {})
+    warn("Caught exception: #{ex}", user_data.merge(:backtrace => ex.backtrace))
+  end
+
+  # Adds a record to the configured sinks.
+  #
+  # @param [Symbol] level_name    The level associated with the record
+  # @param [String] message
+  # @param [Hash] user_data
+  #
+  # @return [nil]
+  def log(level_name, message = nil, user_data = nil, &blk)
+    return unless level_active?(level_name)
+
+    level = self.class.lookup_level(level_name)
+
+    message = yield if block_given?
+
+    callstack = caller
+    loc = parse_record_loc(callstack)
+
+    data = @context.data.merge(user_data || {})
+
+    record = Steno::Record.new(@name, level, message, loc, data)
+
+    @sinks.each { |sink| sink.add_record(record) }
+
+    nil
+  end
+
+  # Returns a proxy that will emit the supplied user data along with each
+  # log record.
+  #
+  # @param [Hash] user_data
+  #
+  # @return [Steno::TaggedLogger]
+  def tag(user_data = {})
+    Steno::TaggedLogger.new(self, user_data)
+  end
+
+  private
+
+  def parse_record_loc(callstack)
+    file, lineno, method = nil, nil, nil
+
+    callstack.each do |frame|
+      next if frame =~ /logger\.rb/
+
+      file, lineno, method = frame.split(":")
+
+      lineno = lineno.to_i
+
+      if method =~ /in `([^']+)/
+        method = $1
+      end
+
+      break
+    end
+
+    [file, lineno, method]
+  end
+end

data/lib/steno/record.rb

@@ -0,0 +1,39 @@
+require "digest/md5"
+require "thread"
+
+module Steno
+end
+
+class Steno::Record
+
+  attr_reader :timestamp
+  attr_reader :message
+  attr_reader :log_level
+  attr_reader :source
+  attr_reader :data
+  attr_reader :thread_id
+  attr_reader :fiber_id
+  attr_reader :process_id
+  attr_reader :file
+  attr_reader :lineno
+  attr_reader :method
+
+  # @param [String] source  Identifies message source.
+  # @param [Symbol] log_level
+  # @param [String] message
+  # @param [Array]  loc        Location where the record was generated.
+  #        Format is [<filename>, <lineno>, <method>].
+  # @param [Hash]   data       User-supplied data
+  def initialize(source, log_level, message, loc = [], data = {})
+    @timestamp  = Time.now
+    @source     = source
+    @log_level  = log_level
+    @message    = message
+    @data       = {}.merge(data)
+    @thread_id  = Thread.current.object_id
+    @fiber_id   = Fiber.current.object_id
+    @process_id = Process.pid
+
+    @file, @lineno, @method = loc
+  end
+end

data/lib/steno/sink.rb

@@ -0,0 +1,3 @@
+require "steno/sink/base"
+require "steno/sink/io"
+require "steno/sink/syslog"

data/lib/steno/sink/base.rb

@@ -0,0 +1,36 @@
+require "thread"
+
+module Steno
+  module Sink
+  end
+end
+
+# Sinks represent the final destination for log records. They abstract storage
+# mediums (like files) and transport layers (like sockets).
+class Steno::Sink::Base
+
+  attr_accessor :codec
+
+  # @param [Steno::Codec::Base] formatter Transforms log records to their
+  # raw, string-based representation that will be written to the underlying
+  # sink.
+  def initialize(codec = nil)
+    @codec = codec
+  end
+
+  # Adds a record to be flushed at a later time.
+  #
+  # @param [Hash] record
+  #
+  # @return [nil]
+  def add_record(record)
+    raise NotImplementedError
+  end
+
+  # Flushes any buffered records.
+  #
+  # @return [nil]
+  def flush
+    raise NotImplementedError
+  end
+end

data/lib/steno/sink/io.rb

@@ -0,0 +1,48 @@
+require "steno/sink/base"
+
+module Steno
+  module Sink
+  end
+end
+
+class Steno::Sink::IO < Steno::Sink::Base
+  class << self
+    # Returns a new sink configured to append to the file at path.
+    #
+    # @param [String] path
+    # @param [True, False] autoflush If true, encoded records will not be
+    #   buffered by Ruby.
+    #
+    # @return [Steno::Sink::IO]
+    def for_file(path, autoflush = true)
+      io = File.open(path, "a+")
+
+      io.sync = autoflush
+
+      new(io)
+    end
+  end
+
+  # @param [IO] io The IO object that will be written to
+  # @param [Steno::Codec::Base] codec
+  def initialize(io, codec = nil)
+    super(codec)
+
+    @io_lock = Mutex.new
+    @io = io
+  end
+
+  def add_record(record)
+    bytes = @codec.encode_record(record)
+
+    @io_lock.synchronize { @io.write(bytes) }
+
+    nil
+  end
+
+  def flush
+    @io_lock.synchronize { @io.flush }
+
+    nil
+  end
+end

data/lib/steno/sink/syslog.rb

@@ -0,0 +1,38 @@
+require "steno/sink/base"
+
+require "singleton"
+require "thread"
+require "syslog"
+
+class Steno::Sink::Syslog < Steno::Sink::Base
+  include Singleton
+
+  LOG_LEVEL_MAP = {
+      :fatal  => Syslog::LOG_CRIT,
+      :error  => Syslog::LOG_ERR,
+      :warn   => Syslog::LOG_WARNING,
+      :info   => Syslog::LOG_INFO,
+      :debug  => Syslog::LOG_DEBUG,
+      :debug1 => Syslog::LOG_DEBUG,
+      :debug2 => Syslog::LOG_DEBUG,
+    }
+
+  def initialize
+    super
+
+    @syslog = nil
+    @syslog_lock = Mutex.new
+  end
+
+  def open(identity)
+    @identity = identity
+    @syslog = Syslog.open(@identity, Syslog::LOG_PID, Syslog::LOG_USER)
+  end
+
+  def add_record(record)
+    msg = @codec.encode_record(record)
+    pri = LOG_LEVEL_MAP[record.log_level]
+    @syslog_lock.synchronize { @syslog.log(pri, "%s", msg) }
+  end
+
+end

data/lib/steno/tagged_logger.rb

@@ -0,0 +1,59 @@
+require "steno/logger"
+
+module Steno
+end
+
+# Provides a proxy that allows persistent user data
+class Steno::TaggedLogger
+
+  attr_reader :proxied_logger
+  attr_accessor :user_data
+
+  class << self
+    # The following helpers are used to create a new scope for binding the log
+    # level.
+
+    def define_log_method(name)
+      define_method(name) { |*args, &blk| log(name, *args, &blk) }
+    end
+
+    def define_logf_method(name)
+      define_method(name.to_s + "f") { |fmt, *args| log(name, fmt % args) }
+    end
+  end
+
+  Steno::Logger::LEVELS.each do |name, _|
+    # Define #debug, for example
+    define_log_method(name)
+
+    # Define #debugf, for example
+    define_logf_method(name)
+  end
+
+  def initialize(proxied_logger, user_data = {})
+    @proxied_logger = proxied_logger
+    @user_data = user_data
+  end
+
+  def method_missing(method, *args, &blk)
+    @proxied_logger.send(method, *args, &blk)
+  end
+
+  # @see Steno::Logger#log
+  def log(level_name, message = nil, user_data = nil, &blk)
+    ud = @user_data.merge(user_data || {})
+
+    @proxied_logger.log(level_name, message, ud, &blk)
+  end
+
+  # @see Steno::Logger#log_exception
+  def log_exception(ex, user_data = {})
+    ud = @user_data.merge(user_data || {})
+
+    @proxied_logger.log_exception(ex, ud)
+  end
+
+  def tag(new_user_data = {})
+    Steno::TaggedLogger.new(proxied_logger, user_data.merge(new_user_data))
+  end
+end

data/lib/steno/version.rb

@@ -0,0 +1,3 @@
+module Steno
+  VERSION = "0.0.3"
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+module Foo
+  class Bar
+  end
+end
+
+describe Class do
+  describe "#logger" do
+    it "should request a logger named after the class" do
+      Steno.should_receive(:logger).with("Foo::Bar")
+      x = Foo::Bar.logger
+    end
+  end
+end