steno-capi 1.3.4

data/lib/steno/sink.rb

@@ -0,0 +1,6 @@
+require "steno/sink/base"
+require "steno/sink/io"
+require "steno/sink/syslog"
+require "steno/sink/fluentd"
+require "steno/sink/counter"
+require "steno/sink/eventlog"

data/lib/steno/sink/base.rb

@@ -0,0 +1,38 @@
+require "rbconfig"
+require "thread"
+
+module Steno
+  module Sink
+    WINDOWS = (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+  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/counter.rb

@@ -0,0 +1,44 @@
+require "steno/sink/base"
+
+module Steno
+  module Sink
+  end
+end
+
+class Steno::Sink::Counter < Steno::Sink::Base
+
+  def initialize
+    # Map of String -> numeric count
+    @counts = {}
+    @mutex = Mutex.new
+  end
+
+  def add_record(record)
+    level = record.log_level.to_s
+
+    @mutex.synchronize do
+      unless @counts[level]
+        @counts[level] = 0
+      end
+      @counts[level] += 1
+    end
+  end
+
+  def flush
+  end
+
+  def to_json
+    hash = {}
+    @mutex.synchronize do
+      Steno::Logger::LEVELS.keys.each do |level_name|
+        hash[level_name] = @counts.fetch(level_name.to_s, 0)
+      end
+    end
+    Yajl::Encoder.encode(hash)
+  end
+
+  # Provide a map of string level -> count. This is thread-safe, the return value is a copy.
+  def counts
+    @mutex.synchronize { @counts.dup }
+  end
+end

data/lib/steno/sink/eventlog.rb

@@ -0,0 +1,46 @@
+if Steno::Sink::WINDOWS
+  require "steno/sink/base"
+
+  require "singleton"
+  require "thread"
+  require 'win32/eventlog'
+
+  class Steno::Sink::Eventlog < Steno::Sink::Base
+    include Singleton
+
+    LOG_LEVEL_MAP = {
+        :fatal => Win32::EventLog::ERROR_TYPE,
+        :error => Win32::EventLog::ERROR_TYPE,
+        :warn => Win32::EventLog::WARN_TYPE,
+        :info => Win32::EventLog::INFO_TYPE,
+        :debug => Win32::EventLog::INFO_TYPE,
+        :debug1 => Win32::EventLog::INFO_TYPE,
+        :debug2 => Win32::EventLog::INFO_TYPE,
+    }
+
+    def initialize
+      super
+      @eventlog = nil
+    end
+
+    def open()
+      @eventlog = Win32::EventLog::open('Application')
+    end
+
+    def add_record(record)
+      msg = @codec.encode_record(record)
+      pri = LOG_LEVEL_MAP[record.log_level]
+
+      @eventlog.report_event(
+          :source => 'CloudFoundry',
+          :event_type => pri,
+          :data => msg
+      )
+    end
+
+    def flush
+      nil
+    end
+
+  end
+end

data/lib/steno/sink/fluentd.rb

@@ -0,0 +1,31 @@
+require 'fluent-logger'
+#
+# Steno sink implementation for Fluentd
+#
+#   See fluentd at http://fluentd.org/
+#   and fluent-logger at https://github.com/fluent/fluent-logger-ruby
+#
+class Steno::Sink::Fluentd < Steno::Sink::Base
+
+  # @param [Hash] opts Key :tag_prefix tag prefix of fluent logs (default: steno)
+  #                    Key :host fluentd host (default: 127.0.0.1)
+  #                    Key :port fluentd port (deafult: 24224)
+  #                    Key :buffer_limit buffer limit of fluent-logger
+  def initialize(opts = {})
+    super
+
+    @fluentd = Fluent::Logger::FluentLogger.new(opts[:tag_prefix] || "steno",
+      :host => opts[:host] || "127.0.0.1",
+      :port => opts[:port] || 24224,
+      :buffer_limit => opts[:buffer_limit] || Fluent::Logger::FluentLogger::BUFFER_LIMIT)
+    @io_lock = Mutex.new
+  end
+
+  def add_record(record)
+    @fluentd.post(record.source, record)
+  end
+
+  def flush
+    nil
+  end
+end

data/lib/steno/sink/io.rb

@@ -0,0 +1,72 @@
+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 [Hash]   If the key :autoflush is set to true, encoded records
+    #                 will not be buffered by Ruby. The key :max_retries
+    #                 is forwarded to Steno::Sink::IO object during creation.
+    # @return [Steno::Sink::IO]
+    def for_file(path, opts = {})
+      autoflush = true
+      if opts.include?(:autoflush)
+        autoflush = opts[:autoflush]
+      end
+
+      io = File.open(path, "a+")
+
+      io.sync = autoflush
+
+      new(io, :max_retries => opts[:max_retries])
+    end
+  end
+
+  attr_reader :max_retries
+
+  # @param [IO] io     The IO object that will be written to
+  # @param [Hash] opts Key :codec is used to specify a codec inheriting from
+  #                    Steno::Codec::Base.
+  #                    Key :max_retries takes an integer value which specifies
+  #                    the number of times the write operation can be retried
+  #                    when IOError is raised while writing a record.
+  def initialize(io, opts = {})
+    super(opts[:codec])
+
+    @max_retries = opts[:max_retries] || -1
+    @io_lock = Mutex.new
+    @io = io
+  end
+
+  def add_record(record)
+    bytes = @codec.encode_record(record)
+
+    @io_lock.synchronize do
+      retries = 0
+      begin
+        @io.write(bytes)
+      rescue IOError => e
+        if retries < @max_retries
+          retries += 1
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    nil
+  end
+
+  def flush
+    @io_lock.synchronize { @io.flush }
+
+    nil
+  end
+end

data/lib/steno/sink/syslog.rb

@@ -0,0 +1,62 @@
+unless Steno::Sink::WINDOWS
+  require "steno/sink/base"
+
+  require "singleton"
+  require "thread"
+  require "syslog/logger"
+
+  class Steno::Sink::Syslog < Steno::Sink::Base
+    include Singleton
+
+    MAX_MESSAGE_SIZE = 1024 * 3
+    TRUNCATE_POSTFIX = "..."
+
+    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::Logger.new(@identity)
+      @syslog = Syslog::Logger.syslog
+    end
+
+    def add_record(record)
+      record = truncate_record(record)
+      msg = @codec.encode_record(record)
+      pri = LOG_LEVEL_MAP[record.log_level]
+      @syslog_lock.synchronize { @syslog.log(pri, "%s", msg) }
+    end
+
+    def flush
+      nil
+    end
+
+    private
+
+    def truncate_record(record)
+      return record if record.message.size <= MAX_MESSAGE_SIZE
+
+      truncated = record.message.slice(0...(MAX_MESSAGE_SIZE - TRUNCATE_POSTFIX.size))
+      truncated << TRUNCATE_POSTFIX
+      Steno::Record.new(record.source, record.log_level,
+                        truncated,
+                        [record.file, record.lineno, record.method],
+                        record.data)
+    end
+  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 = "1.3.4"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "rack/test"
+require "rspec"
+
+require "steno"
+
+Dir["./spec/support/**/*.rb"].each { |file| require file }

data/spec/support/barrier.rb

@@ -0,0 +1,22 @@
+require "thread"
+
+class Barrier
+  def initialize
+    @lock = Mutex.new
+    @cvar = ConditionVariable.new
+    @done = false
+  end
+
+  def release
+    @lock.synchronize do
+      @done = true
+      @cvar.broadcast
+    end
+  end
+
+  def wait
+    @lock.synchronize do
+      @cvar.wait(@lock) if !@done
+    end
+  end
+end

data/spec/support/null_sink.rb

@@ -0,0 +1,17 @@
+class NullSink
+  attr_accessor :records
+
+  def initialize
+    @records = []
+  end
+
+  def add_record(record)
+    @records << record
+
+    nil
+  end
+
+  def flush
+    nil
+  end
+end

data/spec/support/shared_context_specs.rb

@@ -0,0 +1,7 @@
+shared_context :steno_context do
+  it "should support clearing context local data" do
+    context.data["test"] = "value"
+    context.clear
+    expect(context.data["test"]).to be_nil
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,229 @@
+require "fileutils"
+require "yaml"
+
+require "spec_helper"
+
+describe Steno::Config do
+
+  if Steno::Sink::WINDOWS
+    describe ".from_hash" do
+      before :each do
+        @log_path = "some_file"
+
+        @mock_sink_file = double("sink")
+        expect(@mock_sink_file).to receive(:codec=)
+        expect(Steno::Sink::IO).to receive(:for_file).with(@log_path,
+                                                       :max_retries => 5)
+        .and_return(@mock_sink_file)
+
+        @mock_sink_eventlog = double("sink")
+        expect(@mock_sink_eventlog).to receive(:codec=)
+        expect(@mock_sink_eventlog).to receive(:open).with("test")
+        expect(Steno::Sink::Eventlog).to receive(:instance).twice()
+        .and_return(@mock_sink_eventlog)
+      end
+
+      after :each do
+        @config = Steno::Config.from_hash(@hash)
+
+        expect(@config.default_log_level).to eq(:debug2)
+        expect(@config.context.class).to eq(Steno::Context::Null)
+        expect(@config.codec.class).to eq(Steno::Codec::Json)
+
+        expect(@config.sinks.size).to eq(2)
+        expect(@config.sinks).to match_array([@mock_sink_file, @mock_sink_eventlog])
+      end
+
+      it "should work for symbolized keys" do
+        @hash = {
+            :file => @log_path,
+            :level => "debug2",
+            :default_log_level => "warn",
+            :eventlog => "test",
+            :max_retries => 5,
+        }
+      end
+
+      it "should work for non-symbolized keys" do
+        @hash = {
+            "file" => @log_path,
+            "level" => "debug2",
+            "default_log_level" => "warn",
+            "eventlog" => "test",
+            "max_retries" => 5,
+        }
+      end
+
+    end
+  else
+    describe ".from_hash" do
+      before :each do
+        @log_path = "some_file"
+
+        @mock_sink_file = double("sink")
+        allow(@mock_sink_file).to receive(:codec=)
+        expect(Steno::Sink::IO).to receive(:for_file).with(@log_path,
+                                                       :max_retries => 5)
+        .and_return(@mock_sink_file)
+
+        @mock_sink_syslog = double("sink")
+        expect(@mock_sink_syslog).to receive(:codec=)
+        expect(@mock_sink_syslog).to receive(:open).with("test")
+        expect(Steno::Sink::Syslog).to receive(:instance).twice()
+        .and_return(@mock_sink_syslog)
+      end
+
+      after :each do
+        @config = Steno::Config.from_hash(@hash)
+
+        expect(@config.default_log_level).to eq(:debug2)
+        expect(@config.context.class).to eq(Steno::Context::Null)
+        expect(@config.codec.class).to eq(Steno::Codec::Json)
+
+        expect(@config.sinks.size).to eq(2)
+        expect(@config.sinks).to match_array([@mock_sink_file, @mock_sink_syslog])
+      end
+
+      it "should work for symbolized keys" do
+        @hash = {
+            :file => @log_path,
+            :level => "debug2",
+            :default_log_level => "warn",
+            :syslog => "test",
+            :max_retries => 5,
+        }
+      end
+
+      it "should work for non-symbolized keys" do
+        @hash = {
+            "file" => @log_path,
+            "level" => "debug2",
+            "default_log_level" => "warn",
+            "syslog" => "test",
+            "max_retries" => 5,
+        }
+      end
+
+    end
+  end
+
+  describe ".from_file" do
+    before :each do
+      @tmpdir = Dir.mktmpdir
+      @config_path = File.join(@tmpdir, "config.yml")
+      @log_path = File.join(@tmpdir, "test.log")
+    end
+
+    after :each do
+      FileUtils.rm_rf(@tmpdir)
+    end
+
+    it "should return Steno::Config instance with sane defaults" do
+      write_config(@config_path, {})
+
+      config = Steno::Config.from_file(@config_path)
+
+      expect(config.sinks.size).to eq(1)
+      expect(config.sinks[0].class).to eq(Steno::Sink::IO)
+
+      expect(config.default_log_level).to eq(:info)
+
+      expect(config.context.class).to eq(Steno::Context::Null)
+
+      expect(config.codec.class).to eq(Steno::Codec::Json)
+      expect(config.codec.iso8601_timestamps?).to eq(false)
+    end
+
+    it "should configure json codec with readable dates if iso8601_timestamps is true" do
+      write_config(@config_path, {"iso8601_timestamps" => "true"})
+      config = Steno::Config.from_file(@config_path)
+      expect(config.codec.class).to eq(Steno::Codec::Json)
+      expect(config.codec.iso8601_timestamps?).to eq(true)
+    end
+
+    it "should set the default_log_level if a key with the same name is supplied" do
+      write_config(@config_path, {"level" => "debug2"})
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
+
+      write_config(@config_path, {"default_log_level" => "debug2"})
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
+    end
+
+    it "should read the 'level' key if both default_log_level and level are spscified" do
+      write_config(@config_path, {"level" => "debug2",
+                                  "default_log_level" => "warn"})
+      expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
+    end
+
+    it "should add a file sink if the 'file' key is specified" do
+      write_config(@config_path, {"file" => @log_path, "max_retries" => 2})
+      mock_sink = double("sink")
+      expect(mock_sink).to receive(:codec=)
+
+      expect(Steno::Sink::IO).to receive(:for_file).
+          with(@log_path, :max_retries => 2).and_return(mock_sink)
+      config = Steno::Config.from_file(@config_path)
+      expect(config.sinks.size).to eq(1)
+      expect(config.sinks[0]).to eq(mock_sink)
+    end
+
+    if Steno::Sink::WINDOWS
+      it "should add a event sink if the 'eventlog' key is specified" do
+        write_config(@config_path, {"eventlog" => "test"})
+        mock_sink = double("sink")
+        expect(mock_sink).to receive(:open).with("test")
+        expect(mock_sink).to receive(:codec=)
+
+        expect(Steno::Sink::Eventlog).to receive(:instance).twice().and_return(mock_sink)
+
+        config = Steno::Config.from_file(@config_path)
+        expect(config.sinks.size).to eq(1)
+        expect(config.sinks[0]).to eq(mock_sink)
+      end
+    else
+      it "should add a syslog sink if the 'syslog' key is specified" do
+        write_config(@config_path, {"syslog" => "test"})
+        mock_sink = double("sink")
+        expect(mock_sink).to receive(:open).with("test")
+        expect(mock_sink).to receive(:codec=)
+
+        expect(Steno::Sink::Syslog).to receive(:instance).twice().and_return(mock_sink)
+
+        config = Steno::Config.from_file(@config_path)
+        expect(config.sinks.size).to eq(1)
+        expect(config.sinks[0]).to eq(mock_sink)
+      end
+    end
+
+
+
+    it "should add an io sink to stdout if no sinks are explicitly specified in the config file" do
+      write_config(@config_path, {})
+      mock_sink = double("sink")
+      expect(mock_sink).to receive(:codec=)
+
+      expect(Steno::Sink::IO).to receive(:new).with(STDOUT).and_return(mock_sink)
+
+      config = Steno::Config.from_file(@config_path)
+      expect(config.sinks.size).to eq(1)
+      expect(config.sinks[0]).to eq(mock_sink)
+    end
+
+    it "should merge supplied overrides with the file based config" do
+      write_config(@config_path, {"default_log_level" => "debug"})
+
+      context = Steno::Context::ThreadLocal.new
+      config = Steno::Config.from_file(@config_path,
+                                       :default_log_level => "warn",
+                                       :context => context)
+      expect(config.context).to eq(context)
+      expect(config.default_log_level).to eq(:warn)
+    end
+  end
+
+  def write_config(path, config)
+    File.open(path, "w+") do |f|
+      f.write(YAML.dump({"logging" => config}))
+    end
+  end
+end