steno 1.2.2-x86-mingw32

data/lib/steno/context.rb

@@ -0,0 +1,59 @@
+require "fiber"
+require "thread"
+
+class Fiber
+  def __steno_context_data__
+    @__steno_context_data__ ||= {}
+  end
+
+  def __steno_clear_context_data__
+    @__steno_context_data__ = {}
+  end
+end
+
+module Steno
+end
+
+module Steno::Context
+  class Base
+    def data
+      raise NotImplementedError
+    end
+
+    def clear
+      raise NotImplementedError
+    end
+  end
+
+  class Null < Base
+    def data
+      {}
+    end
+
+    def clear
+      nil
+    end
+  end
+
+  class ThreadLocal < Base
+    THREAD_LOCAL_KEY = "__steno_locals__"
+
+    def data
+      Thread.current[THREAD_LOCAL_KEY] ||= {}
+    end
+
+    def clear
+      Thread.current[THREAD_LOCAL_KEY] = {}
+    end
+  end
+
+  class FiberLocal < Base
+    def data
+      Fiber.current.__steno_context_data__
+    end
+
+    def clear
+      Fiber.current.__steno_clear_context_data__
+    end
+  end
+end

data/lib/steno/core_ext.rb

@@ -0,0 +1,11 @@
+class Module
+  def logger
+    Steno.logger(name)
+  end
+end
+
+class Object
+  def logger
+    self.class.logger
+  end
+end

data/lib/steno/errors.rb

@@ -0,0 +1,3 @@
+module Steno
+  class Error < StandardError; end
+end

data/lib/steno/http_handler.rb

@@ -0,0 +1,41 @@
+require "steno"
+
+require "grape"
+
+module Steno
+end
+
+class Steno::HttpHandler < Grape::API
+  format :json
+
+  resource :loggers do
+    get :levels do
+      Steno.logger_level_snapshot
+    end
+
+    put :levels do
+      missing = [:regexp, :level].select { |p| !params.key?(p) }.map(&:to_s)
+
+      if !missing.empty?
+        error!("Missing query parameters: #{missing}", 400)
+      end
+
+      regexp = nil
+      begin
+        regexp = Regexp.new(params[:regexp])
+      rescue => e
+        error!("Invalid regexp", 400)
+      end
+
+      level = params[:level].to_sym
+      if !Steno::Logger::LEVELS.key?(level)
+        levels = Steno::Logger::LEVELS.keys.map(&:to_s)
+        error!("Unknown level: #{level}. Supported levels are: #{levels}", 400)
+      end
+
+      Steno.set_logger_regexp(regexp, level)
+
+      "ok"
+    end
+  end
+end

data/lib/steno/json_prettifier.rb

@@ -0,0 +1,131 @@
+require "digest/md5"
+require "set"
+require "yajl"
+
+module Steno
+end
+
+class Steno::JsonPrettifier
+  FIELD_ORDER = %w[
+    timestamp
+    source
+    process_id
+    thread_id
+    fiber_id
+    location
+    data
+    log_level
+    message
+  ]
+
+  MIN_COL_WIDTH = 14
+
+  class ParseError < StandardError
+  end
+
+  def initialize(excluded_fields = [])
+    @time_format = "%Y-%m-%d %H:%M:%S.%6N"
+    @excluded_fields = Set.new(excluded_fields)
+    @max_src_len = MIN_COL_WIDTH
+  end
+
+  def prettify_line(line)
+    begin
+      json_record = Yajl::Parser.parse(line)
+    rescue Yajl::ParseError => e
+      raise ParseError, e.to_s
+    end
+
+    format_record(json_record)
+  end
+
+  protected
+
+  def format_record(record)
+    record ||= {}
+    fields = []
+
+    FIELD_ORDER.each do |field_name|
+      next if @excluded_fields.include?(field_name)
+
+      exists = nil
+      pred_meth = "check_#{field_name}".to_sym
+      if respond_to?(pred_meth)
+        exists = send(pred_meth, record)
+      elsif record.respond_to?(:has_key?)
+        exists = record.has_key?(field_name)
+      else
+        msg = "Expected the record to be a hash, but received: #{record.class}."
+        raise ParseError, msg
+      end
+
+      if exists
+        fields << send("format_#{field_name}".to_sym, record)
+      else
+        fields << "-"
+      end
+    end
+
+    fields.join(" ") + "\n"
+  end
+
+  def format_timestamp(record)
+    Time.at(record["timestamp"]).strftime(@time_format)
+  end
+
+  def format_source(record)
+    @max_src_len = [@max_src_len, record["source"].length].max
+    record["source"].ljust(@max_src_len)
+  end
+
+  def format_process_id(record)
+    "pid=%-5s" % [record["process_id"]]
+  end
+
+  def format_thread_id(record)
+    "tid=%s" % [shortid(record["thread_id"])]
+  end
+
+  def format_fiber_id(record)
+    "fid=%s" % [shortid(record["fiber_id"])]
+  end
+
+  def check_location(record)
+    %w[file lineno method].reduce(true) { |ok, k| ok && record.has_key?(k) }
+  end
+
+  def format_location(record)
+    parts = record["file"].split("/")
+
+    trimmed_filename = nil
+    if parts.size == 1
+      trimmed_filename = parts[0]
+    else
+      trimmed_filename = parts.slice(-2, 2).join("/")
+    end
+
+    "%s/%s:%s" % [trimmed_filename, record["method"], record["lineno"]]
+  end
+
+  def check_data(record)
+    record["data"].is_a?(Hash)
+  end
+
+  def format_data(record)
+    record["data"].map { |k, v| "#{k}=#{v}" }.join(",")
+  end
+
+  def format_log_level(record)
+    "%7s" % [record["log_level"].upcase]
+  end
+
+  def format_message(record)
+    "-- %s" % [record["message"]]
+  end
+
+  def shortid(data)
+    return "-" if data.nil?
+    digest = Digest::MD5.hexdigest(data.to_s)
+    digest[0, 4]
+  end
+end

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,174 @@
+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)
+
+    message = yield if block_given?
+
+    callstack = caller
+    loc = parse_record_loc(callstack)
+
+    data = @context.data.merge(user_data || {})
+
+    record = Steno::Record.new(@name, level_name, 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