buffering_logger 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2627e4e5a241afc93803674003fc939934a4e927
-  data.tar.gz: b8f2b361b88ea9eca62874a6ac2738ae50640f70
+  metadata.gz: 080b9c7259c8c93409f2e8a25309fd6eabbd14a1
+  data.tar.gz: 1e9ad1c09ee4f5762c8f03b4501f9625b97f2dc6
 SHA512:
-  metadata.gz: 5f3d295ea1a19b7b378f7c01e398a4abb6f2f0f2116b9fd56f2f69986e868603e6fea6dc760e4835b166d8cda1157fc2c7bffa319f902c41eb57e5f40e9659ab
-  data.tar.gz: e4377a98763f6da7d9419b7904af2208f1a67e8baf2d5558b43ad567afe2eb6152d403894f2d8375d198582d81fa033051716900429cfc4186c806177a5f149c
+  metadata.gz: 0875c11661eabb07e1d408617095bd47c68efcf929d50ef8aca051e4d3d3a13ac64b0c204e585c980d9369074aa5586443a80ed1fd12abfb508e3abe8239238e
+  data.tar.gz: 2a91b33942353957749ad3ed0ffd2a9237c500c1da360a7a8f7e3711e6f6859a1d78cdb43b438a6176e8df6b880ba498ac283938c083ff0ab1c25d335163c1b0

data/lib/buffering_logger/buffer.rb

@@ -1,39 +1,66 @@
 # 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.
+# #write and #close. We add #buffered as well.
 module BufferingLogger
   class Buffer
     def initialize(logdev)
       @logdev = logdev
-      @buffer = StringIO.new
+      @mutex = Mutex.new
     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
+    def buffered(transform: nil)
       @buffering = true
       yield
     ensure
-      @buffering = buffering_was
-      flush if !@buffering
+      @buffering = false
+      flush(transform: transform)
     end
 
     def write(msg)
-      @buffer.write(msg)
-      flush if !@buffering
+      if @buffering
+        (buffer || create_buffer).write(msg)
+      else
+        @logdev.write(msg)
+      end
     end
 
-    def flush
-      if @buffer.length > 0
-        @logdev.write @buffer.string
-        @buffer = StringIO.new
+    def close
+      @mutex.synchronize do
+        @logdev.close
       end
     end
 
-    def close
-      flush
-      @logdev.close
+    private
+
+    def flush(transform: nil)
+      if buffer && buffer.length > 0
+        @mutex.synchronize do
+          msg = buffer.string
+          msg = transform.call(msg) if transform
+          @logdev.write(msg)
+        end
+      end
+    ensure
+      unset_buffer if buffer
+    end
+
+    def buffer
+      Thread.current[buffer_id]
     end
+
+    def create_buffer
+      Thread.current[buffer_id] = StringIO.new
+    end
+
+    def unset_buffer
+      Thread.current[buffer_id] = nil
+    end
+
+    def buffer_id
+      "buffering_logger_#{object_id}_buffer"
+    end
+
   end
 end

data/lib/buffering_logger/logger.rb

@@ -22,8 +22,8 @@ module BufferingLogger
       )
     end
 
-    def buffered
-      @logdev.buffered do
+    def buffered(transform: nil)
+      @logdev.buffered(transform: transform) do
         yield
       end
     end

data/lib/buffering_logger/rack_buffer.rb

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

data/lib/buffering_logger/rails.rb

@@ -1,30 +1,11 @@
-require 'buffering_logger'
+require 'rails/railtie'
+require 'active_support/deprecation'
+require 'active_support/core_ext/string/filters'
 
-module BufferingLogger
-  class Railtie < Rails::Railtie
-    initializer :buffering_logger, :before => :initialize_logger do |app|
+ActiveSupport::Deprecation.warn(<<-WARN.squish)
+  "buffering_logger/rails" is deprecated.
+  Please use "buffering_logger/railtie" instead and call BufferingLogger::Railtie.install explicitly.
+WARN
 
-      # 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
+require 'buffering_logger/railtie'
+BufferingLogger::Railtie.install

data/lib/buffering_logger/railtie.rb

@@ -0,0 +1,37 @@
+require 'buffering_logger'
+require 'buffering_logger/rack_buffer'
+require 'rails/railtie'
+
+module BufferingLogger
+  class Railtie < Rails::Railtie
+    def self.install(transform: transform, device: nil, sync: true)
+      initializer :buffering_logger, :before => :initialize_logger do |app|
+        device ||= begin
+          # 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
+        end
+
+        device.sync = true if sync && device.respond_to?(:sync=)
+
+        logger = BufferingLogger::Logger.new(device)
+        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, transform: transform)
+      end
+    end
+  end
+end

data/lib/buffering_logger/single_line_transform.rb

@@ -0,0 +1,28 @@
+module BufferingLogger
+  # This transforms a multiline log into a single line log by replacing newlines
+  # with a special string (a single space by default).
+  #
+  # This is useful for platforms like Heroku where multiline Rails request logs
+  # of one process are interwoven with the request logs of other processes and
+  # other log sources (like the Heroku router).
+  #
+  # If you want to convert newlines into a special string so that you can later
+  # turn them back into newlines (e.g. in Splunk using a
+  # [SEDCMD](http://docs.splunk.com/Documentation/Splunk/latest/admin/Propsconf))
+  # then you can supply a `replacement` argument.
+  class SingleLineTransform
+    REPLACEMENT = ' '.freeze
+    NEWLINE = /\r?\n/.freeze
+
+    def initialize(replacement: REPLACEMENT)
+      @replacement = replacement
+    end
+
+    def call(msg)
+      msg = msg.dup
+      msg.strip!
+      msg.gsub!(NEWLINE, @replacement)
+      msg << "\n"
+    end
+  end
+end

data/lib/buffering_logger.rb

@@ -1,3 +1,6 @@
 require 'buffering_logger/logger'
 require 'buffering_logger/buffer'
 require 'buffering_logger/rack_buffer'
+
+module BufferingLogger
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: buffering_logger
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Jordan Brough
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-10 00:00:00.000000000 Z
+date: 2015-11-23 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.
@@ -22,6 +22,8 @@ files:
 - lib/buffering_logger/logger.rb
 - lib/buffering_logger/rack_buffer.rb
 - lib/buffering_logger/rails.rb
+- lib/buffering_logger/railtie.rb
+- lib/buffering_logger/single_line_transform.rb
 homepage: https://github.com/jordan-brough/buffering_logger
 licenses:
 - MIT
@@ -34,7 +36,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -42,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: BufferingLogger is a logger that buffers log entries and then writes them