lumberjack 1.0.11 → 1.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e3b0ba8a97c6cd9b7c21a8342df5004c6643a7c
-  data.tar.gz: 3f8a63f5387688c867f1ffa8d1e0df6aa6d49b9f
+  metadata.gz: c9c87ea941460683699c83e03f4b9b0fda5bcf92
+  data.tar.gz: c4a9af57b579144b798d47ef6ff19a632050dc25
 SHA512:
-  metadata.gz: 2db9b5b15274ba810178994718f9e19568c4e0dae791fbbac39166ce1905e7c1afc7e16ae54c5c491cbb217ab2db7068464aa45e0adae8b4f4fc0b6982e1b147
-  data.tar.gz: 678ca72d7dfdd683eaa6d47206f57723af461d0f696762aaf5b3796e650d23cb611dea8430dcef33e6de48faa18c5d2f65182e2e15ad6129d069b270ff38a067
+  metadata.gz: aab631be08c9ef9a55c755c42268ba4cc68e0f0aa27d625d43f534c649e9c9c6ce5d270a336984484993c6c9211f7e32f35438d9f01201c6024d142cbbf838af
+  data.tar.gz: 53db84229562c9d90931e9feda302887e13d930d746bb92d2d18a7e4d7029ad7e21205fa82ae35e2e2f8a0247557cb0e06a87f58ea3d7c573e665c13395a2eae

data/{README.rdoc → README.md}

@@ -1,11 +1,12 @@
-= Lumberjack
+# Lumberjack
 
 Lumberjack is a simple, powerful, and fast logging implementation in Ruby. It uses nearly the same API as the Logger class in the Ruby standard library and as ActiveSupport::BufferedLogger in Rails.
 
-== Usage
+## Usage
 
 This code aims to be extremely simple to use. The core interface it the Lumberjack::Logger which is used to log messages (which can be any object) with a specified Severity. Each logger has a level associated with it and messages are only written if their severity is greater than or equal to the level.
 
+```ruby
   logger = Lumberjack::Logger.new("logs/application.log")  # Open a new log file with INFO level
   logger.info("Begin request")
   logger.debug(request.params)  # Message not written unless the level is set to DEBUG
@@ -16,12 +17,13 @@ This code aims to be extremely simple to use. The core interface it the Lumberja
     raise
   end
   logger.info("End request")
+```
 
 This is all you need to know to log messages.
 
-== Features
+## Features
 
-=== Meta data
+### Meta data
 
 When messages are added to the log, additional data about the message is kept in a Lumberjack::LogEntry. This means you don't need to worry about adding the time or process id to your log messages as they will be automatically recorded.
 
@@ -33,18 +35,20 @@ The following information is recorded for each message:
 * process id - The process id (pid) of the process that logged the message.
 * unit of work id - The unique 12 byte hexadecimal number generated for a unit of work.
 
-=== Units Of Work
+### Units Of Work
 
 A unit of work can be used to tie together all log messages within a block. This can be very useful to isolate a group of messages that represent one path through the system. For instance, in a web application, a single request represents a natural unit of work,  and when you are looking through a log file, it is useful to see the entire set of log entries as a unit instead of interspersed with messages from other concurrent requests.
 
+```ruby
   # All log entries in this block will get a common unit of work id.
   Lumberjack.unit_of_work do
     logger.info("Begin request")
     yield
     logger.info("End request")
   end
+```
 
-=== Pluggable Devices
+### Pluggable Devices
 
 When a Logger logs a LogEntry, it sends it to a Lumberjack::Device. Lumberjack comes with a variety of devices for logging to IO streams or files.
 
@@ -56,19 +60,24 @@ When a Logger logs a LogEntry, it sends it to a Lumberjack::Device. Lumberjack c
 
 If you'd like to send you log to a different kind of output, you just need to extend the Device class and implement the +write+ method. Or check out these plugins:
 
-* lumberjack_syslog_device[https://github.com/bdurand/lumberjack_syslog_device] - send your log messages to the system wide syslog service
-* lumberjack_mongo_device[https://github.com/bdurand/lumberjack_mongo_device] - store your log messages to a MongoDB[http://www.mongodb.org/] NoSQL data store
-* lumberjack-couchdb-driver[https://github.com/narkisr/lumberjack-couchdb-driver] - store your log messages to a CouchDB[http://couchdb.apache.org/] NoSQL data store
+* [lumberjack_syslog_device](https://github.com/bdurand/lumberjack_syslog_device) - send your log messages to the system wide syslog service
+* [lumberjack_multi-device](https://github.com/astevens/lumberjack_multi-device) - send log messages to multiple devices
+* [lumberjack_mongo_device](https://github.com/bdurand/lumberjack_mongo_device) - store your log messages to a [MongoDB](http://www.mongodb.org/) NoSQL data store
+* [lumberjack-couchdb-driver](https://github.com/narkisr/lumberjack-couchdb-driver) - store your log messages to a [CouchDB](http://couchdb.apache.org/) NoSQL data store
+* [lumberjack_heroku_device](https://github.com/tonycoco/lumberjack_heroku_device) - log to Heroku's logging system
 
-=== Customize Formatting
+### Customize Formatting
 
 When a message is logged, it is first converted into a string. You can customize how it is converted by adding mappings to a Formatter.
 
+```ruby
   logger.formatter.add(Hash, :pretty_print)  # use the Formatter::PrettyPrintFormatter for all Hashes
   logger.formatter.add(MyClass){|obj| "#{obj.class}@#{obj.id}"}  # use a block to provide a custom format
+```
 
 If you use the built in devices, you can also customize the Template used to format the LogEntry.
   
+```ruby
   # Change the format of the time in the log
   Lumberjack::Logger.new("application.log", :time_format => "%m/%d/%Y %H:%M:%S")
 
@@ -78,8 +87,9 @@ If you use the built in devices, you can also customize the Template used to for
   # Use a custom template as a block that only includes the first character of the severity
   template = lambda{|e| "#{e.severity_label[0, 1]} #{e.time} - #{e.message}"}
   Lumberjack::Logger.new("application.log", :template => template)
+```
 
-=== Buffered Performance
+### Buffered Performance
 
 The logger has hooks for devices that support buffering to increase performance by batching physical writes. Log entries are not guaranteed to be written until the Lumberjack::Logger#flush method is called.
 
@@ -87,46 +97,63 @@ You can use the <tt>:flush_seconds</tt> option on the logger to periodically flu
 
 The built in stream based logging devices use an internal buffer. The size of the buffer (in bytes) can be set with the <tt>:buffer_size</tt> options when initializing a logger. The default behavior is to not to buffer.
 
+```ruby
   # Set buffer to flush after 8K has been written to the log.
   logger = Lumberjack::Logger.new("application.log", :buffer_size => 8192)
   
   # Turn off buffering so entries are immediately written to disk.
   logger = Lumberjack::Logger.new("application.log", :buffer_size => 0)
+```
 
-=== Automatic Log Rolling
+### Automatic Log Rolling
 
 The built in devices include two that can automatically roll log files based either on date or on file size. When a log file is rolled, it will be renamed with a suffix and a new file will be created to receive new log entries. This can keep your log files from growing to unusable sizes and removes the need to schedule an external process to roll the files.
 
 There is a similar feature in the standard library Logger class, but the implementation here is safe to use with multiple processes writing to the same log file.
 
-== Examples
+## Examples
 
 These example are for Rails applications, but there is no dependency on Rails for using this gem. Most of the examples are applicable to any Ruby application.
 
 In a Rails application you can replace the default production logger by adding this to your config/environments/production.rb file:
 
-  # Add the unit of work id to each request
-  config.middleware.insert(0, Lumberjack::Rack::UnitOfWork)
+```ruby
+  # Use the ActionDispatch request id as the unit of work id. This will use just the first chunk of the request id.
+  # If you want to use an abbreviated request id for terseness, change the last argument to `true`
+  config.middleware.insert_after ActionDispatch::RequestId, Lumberjack::Rack::RequestId, false
+  # Use a custom unit of work id to each request
+  # config.middleware.insert(0, Lumberjack::Rack::UnitOfWork)
   # Change the logger to use Lumberjack
   log_file_path = Rails.root + "log" + "#{Rails.env}.log"
   config.logger = Lumberjack::Logger.new(log_file, :level => :warn)
+```
 
 To set up a logger to roll every day at midnight, you could use this code (you can also specify :weekly or :monthly):
 
+```ruby
   config.logger = Lumberjack::Logger.new(log_file_path, :roll => :daily)
+```
 
 To set up a logger to roll log files when they get to 100Mb, you could use this:
 
+```ruby
   config.logger = Lumberjack::Logger.new(log_file_path, :max_size => 100.megabytes)
+```
   
 To change the log message format, you could use this code:
 
+```ruby
   config.logger = Lumberjack::Logger.new(log_file_path, :template => ":time - :message")
+```
 
 To change the log message format to output JSON, you could use this code (this example requires the multi-json gem):
   
+```ruby
   config.logger = Lumberjack::Logger.new(log_file_path, :template => lambda{|e| MultiJson.dump(e)})
+```
 
 To send log messages to syslog instead of to a file, you could use this (require the lumberjack_syslog_device gem):
 
+```ruby
   config.logger = Lumberjack::Logger.new(Lumberjack::SyslogDevice.new)
+```

data/VERSION

@@ -1 +1 @@
-1.0.11
+1.0.12

data/lib/lumberjack/rack.rb

@@ -1,5 +1,6 @@
 module Lumberjack
   module Rack
     require File.expand_path("../rack/unit_of_work.rb", __FILE__)
+    require File.expand_path("../rack/request_id.rb", __FILE__)
   end
 end

data/lib/lumberjack/rack/request_id.rb

@@ -0,0 +1,25 @@
+module Lumberjack
+  module Rack
+    # Support for using the Rails ActionDispatch request id in the log.
+    # The format is expected to be a random UUID and only the first chunk is used for terseness
+    # if the abbreviated argument is true.
+    class RequestId
+      REQUEST_ID = "action_dispatch.request_id".freeze
+  
+      def initialize(app, abbreviated = false)
+        @app = app
+        @abbreviated = abbreviated
+      end
+  
+      def call(env)
+        request_id = env[REQUEST_ID]
+        if request_id && @abbreviated
+          request_id = request_id.split('-'.freeze, 2).first
+        end
+        Lumberjack.unit_of_work(request_id) do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/spec/rack/request_id_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Lumberjack::Rack::RequestId do
+  
+  it "should use the action dispatch request id if it exists" do
+    app = lambda{|env| [200, {"Content-Type" => env["Content-Type"], "Unit-Of-Work" => Lumberjack.unit_of_work_id.to_s}, ["OK"]]}
+    handler = Lumberjack::Rack::RequestId.new(app)
+    
+    response = handler.call("Content-Type" => "text/plain", "action_dispatch.request_id" => "0123-4567-89ab-cdef")
+    response[0].should == 200
+    response[1]["Content-Type"].should == "text/plain"
+    response[1]["Unit-Of-Work"].should == "0123-4567-89ab-cdef"
+    response[2].should == ["OK"]
+  end
+  
+  it "should use an abbreviated action dispatch request id if abbreviated is true" do
+    app = lambda{|env| [200, {"Content-Type" => env["Content-Type"], "Unit-Of-Work" => Lumberjack.unit_of_work_id.to_s}, ["OK"]]}
+    handler = Lumberjack::Rack::RequestId.new(app, true)
+    
+    response = handler.call("Content-Type" => "text/plain", "action_dispatch.request_id" => "0123-4567-89ab-cdef")
+    response[0].should == 200
+    response[1]["Content-Type"].should == "text/plain"
+    response[1]["Unit-Of-Work"].should == "0123"
+    response[2].should == ["OK"]
+  end
+  
+  it "should create a unit of work in a middleware stack if the request id doesn't exist" do
+    app = lambda{|env| [200, {"Content-Type" => env["Content-Type"], "Unit-Of-Work" => Lumberjack.unit_of_work_id.to_s}, ["OK"]]}
+    handler = Lumberjack::Rack::RequestId.new(app)
+    
+    response = handler.call("Content-Type" => "text/plain")
+    response[0].should == 200
+    response[1]["Content-Type"].should == "text/plain"
+    unit_of_work_1 = response[1]["Unit-Of-Work"]
+    response[2].should == ["OK"]
+    
+    response = handler.call("Content-Type" => "text/html")
+    response[0].should == 200
+    response[1]["Content-Type"].should == "text/html"
+    unit_of_work_2 = response[1]["Unit-Of-Work"]
+    response[2].should == ["OK"]
+    
+    unit_of_work_1.should_not == nil
+    unit_of_work_2.should_not == nil
+    unit_of_work_1.should_not == unit_of_work_2
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  version: 1.0.12
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2017-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -46,11 +46,10 @@ email:
 - bbdurand@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
 - MIT_LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - lib/lumberjack.rb
@@ -69,6 +68,7 @@ files:
 - lib/lumberjack/log_entry.rb
 - lib/lumberjack/logger.rb
 - lib/lumberjack/rack.rb
+- lib/lumberjack/rack/request_id.rb
 - lib/lumberjack/rack/unit_of_work.rb
 - lib/lumberjack/severity.rb
 - lib/lumberjack/template.rb
@@ -86,6 +86,7 @@ files:
 - spec/log_entry_spec.rb
 - spec/logger_spec.rb
 - spec/lumberjack_spec.rb
+- spec/rack/request_id_spec.rb
 - spec/rack/unit_of_work_spec.rb
 - spec/severity_spec.rb
 - spec/spec_helper.rb
@@ -95,10 +96,7 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: 
-rdoc_options:
-- "--charset=UTF-8"
-- "--main"
-- README.rdoc
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement