steno 0.0.3

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+spec/reports

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in steno.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 mpage
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Steno
+Steno is a lightweight, modular logging library written specifically to support
+Cloud Foundry.
+
+## Concepts
+
+Steno is composed of three main classes: loggers, sinks, and formatters. Loggers
+are the main entry point for Steno. They consume user input, create structured
+records, and forward said records to the configured sinks. Sinks are the
+ultimate destination for log records. They transform a structured record into
+a string via a formatter and then typically write the transformed string to
+another transport.
+
+## Getting started
+    config = Steno::Config.new(
+      :sinks   => [Steno::Sink::IO.new(STDOUT)],
+      :codec   => Steno::Codec::Json.new,
+      :context => Steno::Context::ThreadLocal.new)
+
+    Steno.init(config)
+
+    logger = Steno.logger("test")
+
+    logger.info("Hello world!")
+
+## File a Bug
+
+To file a bug against Cloud Foundry Open Source and its components, sign up and use our
+bug tracking system: [http://cloudfoundry.atlassian.net](http://cloudfoundry.atlassian.net)

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require "ci/reporter/rake/rspec"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new("spec") do |t|
+  t.rspec_opts = %w[--color --format documentation]
+end
+
+desc "Run all specs and provide output for ci"
+RSpec::Core::RakeTask.new("spec:ci" => "ci:setup:rspec") do |t|
+  t.rspec_opts = %w[--no-color --format documentation]
+end
+

data/lib/steno.rb

@@ -0,0 +1,134 @@
+require "thread"
+
+require "steno/codec"
+require "steno/config"
+require "steno/context"
+require "steno/core_ext"
+require "steno/errors"
+require "steno/log_level"
+require "steno/logger"
+require "steno/tagged_logger"
+require "steno/record"
+require "steno/sink"
+require "steno/version"
+
+module Steno
+  class << self
+
+    attr_reader :config
+    attr_reader :logger_regexp
+
+    # Initializes the logging system. This must be called exactly once before
+    # attempting to use any Steno class methods.
+    #
+    # @param [Steno::Config]
+    #
+    # @return [nil]
+    def init(config)
+      @config = config
+
+      @loggers = {}
+      @loggers_lock = Mutex.new
+
+      @logger_regexp = nil
+      @logger_regexp_level = nil
+
+      nil
+    end
+
+    # Returns (and memoizes) the logger identified by name.
+    #
+    # @param [String] name
+    #
+    # @return [Steno::Logger]
+    def logger(name)
+      @loggers_lock.synchronize do
+        logger = @loggers[name]
+
+        if logger.nil?
+          level = compute_level(name)
+
+          logger = Steno::Logger.new(name, @config.sinks,
+                                     :level => level,
+                                     :context => @config.context)
+
+          @loggers[name] = logger
+        end
+
+        logger
+      end
+    end
+
+    # Sets all loggers whose name matches _regexp_ to _level_. Resets any
+    # loggers whose name matches the previous regexp but not the supplied regexp.
+    #
+    # @param [Regexp] regexp
+    # @param [Symbol] level
+    #
+    # @return [nil]
+    def set_logger_regexp(regexp, level)
+      @loggers_lock.synchronize do
+        @loggers.each do |name, logger|
+          if name =~ regexp
+            logger.level = level
+          elsif @logger_regexp && (name =~ @logger_regexp)
+            # Reset loggers affected by the old regexp but not by the new
+            logger.level = @config.default_log_level
+          end
+        end
+
+        @logger_regexp = regexp
+        @logger_regexp_level = level
+
+        nil
+      end
+    end
+
+    # Clears the logger regexp, if set. Resets the level of any loggers matching
+    # the regex to the default log level.
+    #
+    # @return [nil]
+    def clear_logger_regexp
+      @loggers_lock.synchronize do
+        return if @logger_regexp.nil?
+
+        @loggers.each do |name, logger|
+          if name =~ @logger_regexp
+            logger.level = @config.default_log_level
+          end
+        end
+
+        @logger_regexp = nil
+        @logger_regexp_level = nil
+      end
+
+      nil
+    end
+
+
+    # @return [Hash] Map of logger name => level
+    def logger_level_snapshot
+      @loggers_lock.synchronize do
+        snapshot = {}
+
+        @loggers.each { |name, logger| snapshot[name] = logger.level }
+
+        snapshot
+      end
+    end
+
+    private
+
+    def compute_level(name)
+      if @logger_regexp && name =~ @logger_regexp
+        @logger_regexp_level
+      else
+        @config.default_log_level
+      end
+    end
+  end
+end
+
+# Initialize with an empty config. All log records will swallowed until Steno
+# is re-initialized with sinks.
+Steno.init(Steno::Config.new)

data/lib/steno/codec.rb

@@ -0,0 +1,2 @@
+require "steno/codec/base"
+require "steno/codec/json"

data/lib/steno/codec/base.rb

@@ -0,0 +1,34 @@
+module Steno
+  module Codec
+  end
+end
+
+class Steno::Codec::Base
+  # Encodes the supplied record as a string.
+  #
+  # @param [Hash] record
+  #
+  # @return [String]
+  def encode_record(record)
+    raise NotImplementedError
+  end
+
+  private
+
+  # Hex encodes non-printable ascii characters.
+  #
+  # @param [String] data
+  #
+  # @return [String]
+  def escape_nonprintable_ascii(data)
+    data.chars.map do |c|
+      ord_val = c.ord
+
+      if (ord_val > 31) && (ord_val < 127)
+        c
+      else
+        "\\x%02x" % [ord_val]
+      end
+    end.join
+  end
+end

data/lib/steno/codec/json.rb

@@ -0,0 +1,36 @@
+require "yajl"
+
+require "steno/codec/base"
+
+module Steno
+  module Codec
+  end
+end
+
+class Steno::Codec::Json < Steno::Codec::Base
+  def encode_record(record)
+    msg =
+      if record.message.valid_encoding?
+        record.message
+      else
+        # Treat the message as an arbitrary sequence of bytes.
+        escape_nonprintable_ascii(record.message.dup.force_encoding("BINARY"))
+      end
+
+    h = {
+      "timestamp"  => record.timestamp.to_f,
+      "message"    => msg,
+      "log_level"  => record.log_level.to_s,
+      "source"     => record.source,
+      "data"       => record.data,
+      "thread_id"  => record.thread_id,
+      "fiber_id"   => record.fiber_id,
+      "process_id" => record.process_id,
+      "file"       => record.file,
+      "lineno"     => record.lineno,
+      "method"     => record.method,
+    }
+
+    Yajl::Encoder.encode(h) + "\n"
+  end
+end

data/lib/steno/config.rb

@@ -0,0 +1,56 @@
+require "yaml"
+
+require "steno/codec"
+require "steno/context"
+require "steno/logger"
+require "steno/sink"
+
+module Steno
+end
+
+class Steno::Config
+  class << self
+    def from_file(path, overrides = {})
+      h = YAML.load_file(path)
+
+      opts = {
+        :sinks => [],
+        :default_log_level => h["level"].to_sym,
+      }
+
+      if h["file"]
+        opts[:sinks] << Steno::Sink::IO.for_file(h["file"])
+      end
+
+      if h["syslog"]
+        Steno::Sink::Syslog.instance.open(h["syslog"])
+        opts[:sinks] << Steno::Sink::Syslog.instance
+      end
+
+      if opts[:sinks].empty?
+        opts[:sinks] << Steno::Sink::IO.new(STDOUT)
+      end
+
+      new(opts.merge(overrides))
+    end
+  end
+
+  attr_reader :sinks
+  attr_reader :codec
+  attr_reader :context
+  attr_reader :default_log_level
+
+  def initialize(opts = {})
+    @sinks             = opts[:sinks] || []
+    @codec             = opts[:codec] || Steno::Codec::Json.new
+    @context           = opts[:context] ||Steno::Context::Null.new
+
+    @sinks.each { |sink| sink.codec = @codec }
+
+    if opts[:default_log_level]
+      @default_log_level = opts[:default_log_level].to_sym
+    else
+      @default_log_level = :info
+    end
+  end
+end

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,5 @@
+class Class
+  def logger
+    Steno.logger(name)
+  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,42 @@
+require "steno"
+
+require "grape"
+
+module Steno
+end
+
+class Steno::HttpHandler < Grape::API
+  format :json
+  error_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