buffering_logger 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd136895dcc57b5a55668e5667661afc9f2862cc
+  data.tar.gz: 2a6ff2532bb7c27445504613947d919fcc6c3680
+SHA512:
+  metadata.gz: d29f06ff7715d96976cf797740c8c10e4494d4bc1b5026d2fb08e2b3cd5049d1ef81f2cb069731d878895461fb2fc2b02355fd8e7b03bc80ed4d5303bcbd7229
+  data.tar.gz: 41cba79ea6091ae71cf3099268490a223cbc39a03f4f99faba2c4d39e950c6c341bf498f565a063d96fbc184346a220ca8c0c06a46557d2811454008f71991df

data/lib/buffering_logger/buffer.rb

@@ -0,0 +1,39 @@
+# Buffer is used to wrap the logger's logdev to accomplish buffering.
+# For the purposes of the Logger class a LogDevice only needs to implement
+# #write and #close. We add #buffer and #flush as well.
+module BufferingLogger
+  class Buffer
+    def initialize(logdev)
+      @logdev = logdev
+      @buffer = []
+    end
+
+    # buffers during the block and then flushes.
+    # returns the value of the block.
+    def buffered
+      buffering_was = @buffering # in case we're already buffering
+      @buffering = true
+      yield
+    ensure
+      @buffering = buffering_was
+      flush if !@buffering
+    end
+
+    def write(msg)
+      @buffer << msg
+      flush if !@buffering
+    end
+
+    def flush
+      if @buffer.any?
+        @logdev.write @buffer.join
+        @buffer.clear
+      end
+    end
+
+    def close
+      flush
+      @logdev.close
+    end
+  end
+end

data/lib/buffering_logger/logger.rb

@@ -0,0 +1,31 @@
+require 'logger'
+
+# Buffering happens within a #buffered block, like:
+#   logger.buffered { logger.info 'hi'; logger.info 'goodbye' }
+# Buffering is implemented by wrapping the logger @logdev object with a Buffer.
+
+module BufferingLogger
+  class Logger < ::Logger
+
+    def initialize(logdev, shift_age: 0, shift_size: 1048576)
+      @shift_age, @shift_size = shift_age, shift_size
+      super(nil, shift_age, shift_size)
+      self.logdev = logdev
+    end
+
+    # allow changing the log destination. e.g.: in Unicorn during after_fork to
+    # set a separate log path for each worker.
+    def logdev=(logdev)
+      @logdev.close if @logdev
+      @logdev = Buffer.new(
+        LogDevice.new(logdev, shift_age: @shift_age, shift_size: @shift_size)
+      )
+    end
+
+    def buffered
+      @logdev.buffered do
+        yield
+      end
+    end
+  end
+end

data/lib/buffering_logger/rack_buffer.rb

@@ -0,0 +1,11 @@
+module BufferingLogger
+  class RackBuffer
+    def initialize(app, logger)
+      @app, @logger = app, logger
+    end
+
+    def call(env)
+      @logger.buffered { @app.call(env) }
+    end
+  end
+end

data/lib/buffering_logger/rails.rb

@@ -0,0 +1,30 @@
+require 'buffering_logger'
+
+module BufferingLogger
+  class Railtie < Rails::Railtie
+    initializer :buffering_logger, :before => :initialize_logger do |app|
+
+      # Does mostly the same things that Rails does. See http://git.io/2v9FxQ
+
+      path = app.paths["log"].first
+
+      unless File.exist? File.dirname path
+        FileUtils.mkdir_p File.dirname path
+      end
+
+      file = File.open(path, 'a')
+      file.binmode
+      file.sync = true # always flush to disk when write happen
+
+      logger = BufferingLogger::Logger.new(file)
+      logger.formatter = app.config.log_formatter
+      logger = ActiveSupport::TaggedLogging.new(logger)
+
+      app.config.logger = logger
+
+      # Inserts at the very beginning so that all logs, even from other
+      # middleware, get buffered together.
+      app.config.middleware.insert(0, BufferingLogger::RackBuffer, logger)
+    end
+  end
+end

data/lib/buffering_logger.rb

@@ -0,0 +1,3 @@
+require 'buffering_logger/logger'
+require 'buffering_logger/buffer'
+require 'buffering_logger/rack_buffer'

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: buffering_logger
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jordan Brough
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-10 00:00:00.000000000 Z
+dependencies: []
+description: Buffering makes it possible for log tools like Splunk or Logstash to
+  more reliably group multiline logs as single events.
+email: rubygems.j@brgh.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/buffering_logger.rb
+- lib/buffering_logger/buffer.rb
+- lib/buffering_logger/logger.rb
+- lib/buffering_logger/rack_buffer.rb
+- lib/buffering_logger/rails.rb
+homepage: https://github.com/jordan-brough/buffering_logger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: BufferingLogger is a logger that buffers log entries and then writes them
+  all at once.
+test_files: []