buffered-logger 1.0.0

data/lib/buffered_logger.rb

@@ -0,0 +1,37 @@
+require "logger"
+
+class BufferedLogger < Logger
+  require "buffered_logger/errors"
+  require "buffered_logger/log_device_proxy"
+  require "buffered_logger/middleware"
+  require "buffered_logger/version"
+
+  def initialize(*)
+    super
+    @logdev = LogDeviceProxy.new(@logdev)
+  end
+
+  def end
+    raise NotStartedError, "not started" unless started?
+    @logdev.end
+  end
+
+  def start(&block)
+    raise AlreadyStartedError, "already started" if started?
+    @logdev.start
+
+    if block_given?
+      begin
+        yield
+      ensure
+        self.end
+      end
+    else
+      true
+    end
+  end
+
+  def started?
+    @logdev.started?
+  end
+end

data/lib/buffered_logger/errors.rb

@@ -0,0 +1,6 @@
+class BufferedLogger
+  class AlreadyStartedError < StandardError
+  end
+  class NotStartedError < StandardError
+  end
+end

data/lib/buffered_logger/log_device_proxy.rb

@@ -0,0 +1,32 @@
+class BufferedLogger
+  class LogDeviceProxy
+    def initialize(logdev)
+      @logdev = logdev
+      @buffers = {}
+    end
+
+    def close
+      @logdev.close
+    end
+
+    def end
+      @logdev.write(@buffers.delete(Thread.current).string)
+    end
+
+    def start
+      @buffers[Thread.current] = StringIO.new
+    end
+
+    def started?
+      @buffers.key?(Thread.current)
+    end
+
+    def write(message)
+      if started?
+        @buffers[Thread.current].write(message)
+      else
+        @logdev.write(message)
+      end
+    end
+  end
+end

data/lib/buffered_logger/middleware.rb

@@ -0,0 +1,11 @@
+class BufferedLogger
+  class Middleware
+    def initialize(app, logger)
+      @app, @logger = app, logger
+    end
+
+    def call(env)
+      @logger.start { @app.call(env) }
+    end
+  end
+end

data/lib/buffered_logger/rails.rb

@@ -0,0 +1,21 @@
+require "buffered_logger"
+require "rails"
+
+class BufferedLogger
+  class Railtie < Rails::Railtie
+    initializer :buffered_logger, :before => :initialize_logger do |app|
+      if Rails::VERSION::STRING >= "3.1"
+        path = app.paths["log"].first
+      else
+        path = app.paths.log.to_a.first
+      end
+
+      file = File.open(path, "a")
+      file.binmode
+      file.sync = true
+
+      app.config.logger = BufferedLogger.new(file)
+      app.config.middleware.insert(0, BufferedLogger::Middleware, app.config.logger)
+    end
+  end
+end

data/lib/buffered_logger/version.rb

@@ -0,0 +1,5 @@
+require "logger"
+
+class BufferedLogger < Logger
+  VERSION = "1.0.0"
+end

data/test/buffered_logger/log_device_proxy_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+describe BufferedLogger::LogDeviceProxy do
+  def setup
+    @logdev = mock()
+    @proxy = BufferedLogger::LogDeviceProxy.new(@logdev)
+  end
+
+  it "should call write" do
+    @logdev.expects(:write)
+    @proxy.write("message")
+  end
+
+  it "should call close on the logdev when close is called" do
+    @logdev.expects(:close)
+    @proxy.close
+  end
+
+  it "should not call write on the logdev once started" do
+    @logdev.expects(:write).never
+    @proxy.start
+    @proxy.write("message")
+  end
+
+  it "should be started? once started" do
+    @proxy.start
+    assert @proxy.started?
+  end
+
+  it "should call write once started and ended" do
+    @logdev.expects(:write)
+    @proxy.start
+    @proxy.write("message")
+    @proxy.end
+  end
+
+  it "should buffer all writes and write them once" do
+    @logdev.expects(:write).with("123")
+    @proxy.start
+    @proxy.write("1")
+    @proxy.write("2")
+    @proxy.write("3")
+    @proxy.end
+  end
+end

data/test/buffered_logger/middleware_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+describe BufferedLogger::Middleware do
+  def setup
+    @app = mock()
+    @app.stubs(:call).returns([200, {}, []])
+    @logger = mock()
+    def @logger.start; yield; end
+    @middleware = BufferedLogger::Middleware.new(@app, @logger)
+  end
+
+  it "should call start" do
+    @logger.expects(:start).yields()
+    @middleware.call(nil)
+  end
+
+  it "behaves as a proper rack middleware" do
+    result = [200, {}, []]
+    env = mock()
+    @app.expects(:call).with(env).returns(result)
+    @middleware.call(env).must_equal(result)
+  end
+end

data/test/buffered_logger_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+class MockLogDeviceProxy
+  def initialize
+    @started = false
+  end
+
+  def end
+    @started = false
+  end
+
+  def start
+    @started = true
+
+    if block_given?
+      begin
+        yield
+      ensure
+        @started = false
+      end
+    else
+      true
+    end
+  end
+
+  def started?
+    @started
+  end
+end
+
+describe BufferedLogger do
+  describe "with MockLogDeviceProxy" do
+    def setup
+      @logdev = MockLogDeviceProxy.new
+      @logger = BufferedLogger.allocate
+      @logger.instance_variable_set(:@logdev, @logdev)
+    end
+
+    it "should raise an error if end is called while not started" do
+      -> { @logger.end }.must_raise(BufferedLogger::NotStartedError)
+    end
+
+    it "should raise an error if start is called while already started" do
+      @logger.start
+      -> { @logger.start }.must_raise(BufferedLogger::AlreadyStartedError)
+    end
+  end
+
+  describe "with mock" do
+    def setup
+      @logdev = mock()
+      @logger = BufferedLogger.allocate
+      @logger.instance_variable_set(:@logdev, @logdev)
+    end
+
+    it "should call end on logdev" do
+      @logdev.expects(:end)
+      @logdev.stubs(:started?).returns(true)
+      @logger.end
+    end
+
+    it "should call start on logdev" do
+      @logdev.expects(:start)
+      @logdev.stubs(:started?).returns(false)
+      @logger.start
+    end
+
+    it "should call started? on logdev" do
+      @logdev.expects(:started?)
+      @logger.started?
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: buffered-logger
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Samuel Kadolph
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+description: buffered-logger is designed to be used in multithreaded rack servers
+  and includes a middleware to automatically capture and write the buffered log statements
+  during each request.
+email:
+- samuel@kadolph.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/buffered_logger/errors.rb
+- lib/buffered_logger/log_device_proxy.rb
+- lib/buffered_logger/middleware.rb
+- lib/buffered_logger/rails.rb
+- lib/buffered_logger/version.rb
+- lib/buffered_logger.rb
+- test/buffered_logger/log_device_proxy_test.rb
+- test/buffered_logger/middleware_test.rb
+- test/buffered_logger_test.rb
+homepage: http://samuelkadolph.github.com/buffered-logger
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: buffered-logger is a concurrency safe logger. It buffers each logging statement
+  and writes to the log file all at once.
+test_files:
+- test/buffered_logger/log_device_proxy_test.rb
+- test/buffered_logger/middleware_test.rb
+- test/buffered_logger_test.rb
+has_rdoc: