logstasher 0.5.3 → 0.6.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDVhMmFhNjI3MDBmNmI4N2RlNWEzZTAyODNiMjk2ZGRkMzNlNzA5Yw==
+    MmUyOWU0M2UwMGY1YzRjZDU0ZDRmNGExM2E2YTZjZDVhMGEyYWRjMQ==
   data.tar.gz: !binary |-
-    ZWZmMTdmOTdmODFkZDkyYTUzYWQ1Mzk1MjgzODNlMTlkZDM5ZTgwNg==
+    NGI2M2M3NGNjYjc2OGZjMWI0NGU3MTM3ZjljMDY5ZGNhYTk5OTYxNQ==
 SHA512:
   metadata.gz: !binary |-
-    ZDcxZmFkNGUxZjI5Mzk5NDg2ZDhjMjZlN2U0OTY4MzdhOWNmZmIyYTNmY2E1
-    NzkxYWQ2OWYyMTMxNGMwNjdlMTViNWVjNzExNzQ4NjEyZjFjN2RlMjVmYThk
-    MjBjYzNlZjdhN2M4ZWRkNWJmN2FmZTBkNmQ2MjM2MzlkYzQyYjM=
+    YjM5YzhmMGU0YTcyYTAxMWMxYzAxZWE5NTgyN2RmYTM3MWM0ZDE0MTY1YWQ2
+    YzIzOWQ4MjFkODA0NDMwNDk3YWY4MmNkYzY1M2ViNmU4NjZmYzdjMDZlMGU2
+    ZGM2MGY0ZmNjYzk3NTYwODRiMTc3ZDg1OTYzZWFiMTgzNmEyZjA=
   data.tar.gz: !binary |-
-    MmM5Y2JjZDY5OTU0ZWMzNTc1YTljM2Y1OTM2M2JmZDIwYTYwN2Q3ZTJmYzI3
-    Yjg5NDgwYTEzMmZiMDk2OGNhNzQyZjlmM2E3NTQ4MTM1OTY3YzA5NzJhOWNk
-    ZDA3MzUxMzFlZGI0ZTJkZDIxOWE0NGE2NjU1ZTJjODA3OGFmNzE=
+    NTk2MDFmNGM4MDFlOGE2OGI1NjE3MDMwZmZmYjRlZTM0NDQwMTU1OGZiMzBl
+    N2VlYzViNzQ2MDFjODk4OWYyYThhZGRjNzUyMDRhNzBiZjU3YTdhM2E0ZjJj
+    ZTRlYTA2Y2UyM2UzN2M0YTY5MDFkY2IyNzk1NmY5MzM5MjJlOGQ=

data/README.md

@@ -94,6 +94,15 @@ Since some fields are very specific to your application for e.g. *user_name*, so
       end
     end
 
+## Logging ActionMailer events
+
+Logstasher can easily log messages from `ActionMailer`, such as incoming/outgoing e-mails and e-mail content generation (Rails >= 4.1).
+This functionality is automatically enabled. Since the relationship between a concrete HTTP request and a mailer invocation is lost
+once in an `ActionMailer` instance method, global (per-request) state is kept to correlate HTTP requests and events from other parts
+of rails, such as `ActionMailer`. Every time a request is invoked, a `request_id` key is added which is present on every `ActionMailer` event.
+
+Note: Since mailers are executed within the lifetime of a request, they will show up in logs prior to the actual request.
+
 ## Listening to `ActiveSupport::Notifications` events
 
 It is possible to listen to any `ActiveSupport::Notifications` events and store arbitrary data to be included in the final JSON log entry:
@@ -135,7 +144,7 @@ You can easily share the same store between different types of notifications, by
 java -jar logstash-1.3.3-flatjar.jar agent -f quickstart.conf -- web
 ```
 * Visit http://localhost:9292/ to see the Kibana interface and your parsed logs
-* For advanced options see the latest logstash documentation at [logstash.net](http://www.logstash.net/) or visit my blog at (shadabahmed.com)[http://shadabahmed.com/blog/2013/04/30/logstasher-for-awesome-rails-logging] (slightly outdated but will sure give you ideas for distributed setup etc.)
+* For advanced options see the latest logstash documentation at [logstash.net](http://www.logstash.net/) or visit my blog at [shadabahmed.com](http://shadabahmed.com/blog/2013/04/30/logstasher-for-awesome-rails-logging) (slightly outdated but will sure give you ideas for distributed setup etc.)
 
 ## Versions
 All versions require Rails 3.0.x and higher and Ruby 1.9.2+. Tested on Rails 4 and Ruby 2.0

data/lib/logstasher.rb

@@ -8,8 +8,9 @@ require 'active_support/ordered_options'
 module LogStasher
   extend self
   STORE_KEY = :logstasher_data
+  REQUEST_CONTEXT_KEY = :logstasher_request_context
 
-  attr_accessor :logger, :enabled, :log_controller_parameters, :source
+  attr_accessor :logger, :logger_path, :enabled, :log_controller_parameters, :source
   # Setting the default to 'unknown' to define the default behaviour
   @source = 'unknown'
 
@@ -20,6 +21,8 @@ module LogStasher
           unsubscribe(:action_view, subscriber)
         when ActionController::LogSubscriber
           unsubscribe(:action_controller, subscriber)
+        when ActionMailer::LogSubscriber
+          unsubscribe(:action_mailer, subscriber)
       end
     end
   end
@@ -38,7 +41,8 @@ module LogStasher
   def add_default_fields_to_payload(payload, request)
     payload[:ip] = request.remote_ip
     payload[:route] = "#{request.params[:controller]}##{request.params[:action]}"
-    self.custom_fields += [:ip, :route]
+    payload[:request_id] = request.env['action_dispatch.request_id']
+    self.custom_fields += [:ip, :route, :request_id]
     if self.log_controller_parameters
       payload[:parameters] = payload[:params].except(*ActionController::LogSubscriber::INTERNAL_PARAMS)
       self.custom_fields += [:parameters]
@@ -54,6 +58,23 @@ module LogStasher
     ActionController::Base.send(:define_method, :logtasher_add_custom_fields_to_payload, &wrapped_block)
   end
 
+  def add_custom_fields_to_request_context(&block)
+    wrapped_block = Proc.new do |fields|
+      instance_exec(fields, &block)
+      LogStasher.custom_fields.concat(fields.keys)
+    end
+    ActionController::Metal.send(:define_method, :logstasher_add_custom_fields_to_request_context, &wrapped_block)
+    ActionController::Base.send(:define_method, :logstasher_add_custom_fields_to_request_context, &wrapped_block)
+  end
+
+  def add_default_fields_to_request_context(request)
+    request_context[:request_id] = request.env['action_dispatch.request_id']
+  end
+
+  def clear_request_context
+    request_context.clear
+  end
+
   def setup(app)
     app.config.action_dispatch.rack_cache[:verbose] = false if app.config.action_dispatch.rack_cache
     # Path instrumentation class to insert our hook
@@ -61,7 +82,9 @@ module LogStasher
     require 'logstash-event'
     self.suppress_app_logs(app)
     LogStasher::RequestLogSubscriber.attach_to :action_controller
-    self.logger = app.config.logstasher.logger || new_logger("#{Rails.root}/log/logstash_#{Rails.env}.log")
+    LogStasher::MailerLogSubscriber.attach_to :action_mailer
+    self.logger_path = app.config.logstasher.logger_path || "#{Rails.root}/log/logstash_#{Rails.env}.log"
+    self.logger = app.config.logstasher.logger || new_logger(self.logger_path)
     self.logger.level = app.config.logstasher.log_level || Logger::WARN
     self.source = app.config.logstasher.source unless app.config.logstasher.source.nil?
     self.enabled = true
@@ -103,6 +126,10 @@ module LogStasher
     RequestStore.store[STORE_KEY]
   end
 
+  def request_context
+    RequestStore.store[REQUEST_CONTEXT_KEY] ||= {}
+  end
+
   def watch(event, opts = {}, &block)
     event_group = opts[:event_group] || event
     ActiveSupport::Notifications.subscribe(event) do |*args|
@@ -119,6 +146,10 @@ module LogStasher
     EOM
   end
 
+  def enabled?
+    self.enabled
+  end
+
   private
 
   def new_logger(path)

data/lib/logstasher/log_subscriber.rb

@@ -93,4 +93,35 @@ module LogStasher
       custom_fields
     end
   end
+
+  class MailerLogSubscriber < ActiveSupport::LogSubscriber
+    MAILER_FIELDS = [:mailer, :action, :message_id, :from, :to]
+
+    def deliver(event)
+      process_event(event, ['mailer', 'deliver'])
+    end
+
+    def receive(event)
+      process_event(event, ['mailer', 'receive'])
+    end
+
+    def process(event)
+      process_event(event, ['mailer', 'process'])
+    end
+
+    private
+    def process_event(event, tags)
+      data = LogStasher.request_context.merge(extract_metadata(event.payload))
+      event = LogStash::Event.new('@source' => LogStasher.source, '@fields' => data, '@tags' => tags)
+      logger << event.to_json + "\n"
+    end
+
+    def extract_metadata(payload)
+      payload.slice(*MAILER_FIELDS)
+    end
+
+    def logger
+      LogStasher.logger
+    end
+  end
 end

data/lib/logstasher/rails_ext/action_controller/metal/instrumentation.rb

@@ -12,9 +12,16 @@ module ActionController
 
       LogStasher.add_default_fields_to_payload(raw_payload, request)
 
+      LogStasher.clear_request_context
+      LogStasher.add_default_fields_to_request_context(request)
+
       ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
 
       ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
+        if self.respond_to?(:logstasher_add_custom_fields_to_request_context)
+          logstasher_add_custom_fields_to_request_context(LogStasher.request_context)
+        end
+
         result = super
 
         if self.respond_to?(:logtasher_add_custom_fields_to_payload)
@@ -30,6 +37,10 @@ module ActionController
         LogStasher.store.each do |key, value|
           payload[key] = value
         end
+
+        LogStasher.request_context.each do |key, value|
+          payload[key] = value
+        end
         result
       end
     end

data/lib/logstasher/version.rb

@@ -1,3 +1,3 @@
 module LogStasher
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/logstasher.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "request_store"
 
   # specify any dependencies here; for example:
-  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec", [">= 2.14"]
   s.add_development_dependency("bundler", [">= 1.0.0"])
   s.add_development_dependency("rails", [">= 3.0"])
 end

data/spec/lib/logstasher/device/redis_spec.rb

@@ -13,28 +13,28 @@ describe LogStasher::Device::Redis do
 
   it 'has default options' do
     device = LogStasher::Device::Redis.new
-    device.options.should eq(default_options)
+    expect(device.options).to eq(default_options)
   end
 
   it 'creates a redis instance' do
-    ::Redis.should_receive(:new).with({})
+    expect(::Redis).to receive(:new).with({})
     LogStasher::Device::Redis.new()
   end
 
   it 'assumes unknown options are for redis' do
-    ::Redis.should_receive(:new).with(hash_including(db: '0'))
+    expect(::Redis).to receive(:new).with(hash_including(db: '0'))
     device = LogStasher::Device::Redis.new(db: '0')
-    device.redis_options.should eq(db: '0')
+    expect(device.redis_options).to eq(db: '0')
   end
 
   it 'has a key' do
     device = LogStasher::Device::Redis.new(key: 'the_key')
-    device.key.should eq 'the_key'
+    expect(device.key).to eq('the_key')
   end
 
   it 'has a data_type' do
     device = LogStasher::Device::Redis.new(data_type: 'channel')
-    device.data_type.should eq 'channel'
+    expect(device.data_type).to eq('channel')
   end
 
   it 'does not allow unsupported data types' do
@@ -45,13 +45,13 @@ describe LogStasher::Device::Redis do
 
   it 'quits the redis connection on #close' do
     device = LogStasher::Device::Redis.new
-    device.redis.should_receive(:quit)
+    expect(device.redis).to receive(:quit)
     device.close
   end
 
   it 'works as a logger device' do
     device = LogStasher::Device::Redis.new
-    device.should_receive(:write).with('blargh')
+    expect(device).to receive(:write).with('blargh')
     logger = Logger.new(device)
     logger << 'blargh'
   end
@@ -59,19 +59,19 @@ describe LogStasher::Device::Redis do
   describe '#write' do
     it "rpushes logs onto a list" do
       device = LogStasher::Device::Redis.new(data_type: 'list')
-      device.redis.should_receive(:rpush).with('logstash', 'the log')
+      expect(device.redis).to receive(:rpush).with('logstash', 'the log')
       device.write('the log')
     end
 
     it "rpushes logs onto a custom key" do
       device = LogStasher::Device::Redis.new(data_type: 'list', key: 'custom')
-      device.redis.should_receive(:rpush).with('custom', 'the log')
+      expect(device.redis).to receive(:rpush).with('custom', 'the log')
       device.write('the log')
     end
 
     it "publishes logs onto a channel" do
       device = LogStasher::Device::Redis.new(data_type: 'channel', key: 'custom')
-      device.redis.should_receive(:publish).with('custom', 'the log')
+      expect(device.redis).to receive(:publish).with('custom', 'the log')
       device.write('the log')
     end
   end

data/spec/lib/logstasher/instrumentation_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'logstasher/rails_ext/action_controller/metal/instrumentation'
+
+describe ActionController::Base do
+  before :each do
+    subject.request = ActionDispatch::TestRequest.new
+    subject.response = ActionDispatch::TestResponse.new
+
+    def subject.index(*args)
+      render text: 'OK'
+    end
+  end
+
+  describe ".process_action" do
+    it "adds default fields to payload" do
+      expect(LogStasher).to receive(:add_default_fields_to_payload).once
+      expect(LogStasher).to receive(:add_default_fields_to_request_context).once
+      subject.process_action(:index)
+    end
+
+    it "creates the request context before processing" do
+      LogStasher.request_context[:some_key] = 'value'
+      expect(LogStasher).to receive(:clear_request_context).once.and_call_original
+      expect {
+        subject.process_action(:index)
+      }.to change { LogStasher.request_context }
+    end
+
+    it "notifies rails of a request coming in" do
+      expect(ActiveSupport::Notifications).to receive(:instrument).with("start_processing.action_controller", anything).once
+      expect(ActiveSupport::Notifications).to receive(:instrument).with("process_action.action_controller", anything).once
+      subject.process_action(:index)
+    end
+
+    context "request context has custom fields defined" do
+      before :each do
+        LogStasher.add_custom_fields_to_request_context do |fields|
+          fields[:some_field] = 'value'
+        end
+
+        ActiveSupport::Notifications.subscribe('process_action.action_controller') do |_, _, _, _, payload|
+          @payload = payload
+        end
+      end
+
+      it "should retain the value in the request context" do
+        subject.process_action(:index)
+      end
+
+      after :each do
+        expect(@payload[:some_field]).to eq('value')
+
+        ActionController::Metal.class_eval do
+          undef logstasher_add_custom_fields_to_request_context
+        end
+        ActionController::Base.class_eval do
+          undef logstasher_add_custom_fields_to_request_context
+        end
+      end
+    end
+  end
+end

data/spec/lib/logstasher/log_subscriber_spec.rb

@@ -45,17 +45,17 @@ describe LogStasher::RequestLogSubscriber do
     let(:logger)  { double }
     let(:json)    { "{\"@source\":\"unknown\",\"@tags\":[\"request\"],\"@fields\":{\"request\":true,\"status\":true,\"runtimes\":true,\"location\":true,\"exception\":true,\"custom\":true},\"@timestamp\":\"timestamp\"}\n" }
     before do
-      LogStasher.stub(:logger => logger)
-      LogStash::Time.stub(:now => 'timestamp')
+      allow(LogStasher).to receive(:logger).and_return(logger)
+      allow(LogStash::Time).to receive(:now).and_return('timestamp')
     end
     it 'calls all extractors and outputs the json' do
-      request_subscriber.should_receive(:extract_request).with(payload).and_return({:request => true})
-      request_subscriber.should_receive(:extract_status).with(payload).and_return({:status => true})
-      request_subscriber.should_receive(:runtimes).with(event).and_return({:runtimes => true})
-      request_subscriber.should_receive(:location).with(event).and_return({:location => true})
-      request_subscriber.should_receive(:extract_exception).with(payload).and_return({:exception => true})
-      request_subscriber.should_receive(:extract_custom_fields).with(payload).and_return({:custom => true})
-      LogStasher.logger.should_receive(:<<).with(json)
+      expect(request_subscriber).to receive(:extract_request).with(payload).and_return({:request => true})
+      expect(request_subscriber).to receive(:extract_status).with(payload).and_return({:status => true})
+      expect(request_subscriber).to receive(:runtimes).with(event).and_return({:runtimes => true})
+      expect(request_subscriber).to receive(:location).with(event).and_return({:location => true})
+      expect(request_subscriber).to receive(:extract_exception).with(payload).and_return({:exception => true})
+      expect(request_subscriber).to receive(:extract_custom_fields).with(payload).and_return({:custom => true})
+      expect(LogStasher.logger).to receive(:<<).with(json)
       request_subscriber.process_action(event)
     end
   end
@@ -64,47 +64,47 @@ describe LogStasher::RequestLogSubscriber do
 
     it "should contain request tag" do
       subscriber.process_action(event)
-      log_output.json['@tags'].should include 'request'
+      expect(log_output.json['@tags']).to include 'request'
     end
 
     it "should contain HTTP method" do
       subscriber.process_action(event)
-      log_output.json['@fields']['method'].should == 'GET'
+      expect(log_output.json['@fields']['method']).to eq 'GET'
     end
 
     it "should include the path in the log output" do
       subscriber.process_action(event)
-      log_output.json['@fields']['path'].should == '/home'
+      expect(log_output.json['@fields']['path']).to eq '/home'
     end
 
     it "should include the format in the log output" do
       subscriber.process_action(event)
-      log_output.json['@fields']['format'].should == 'application/json'
+      expect(log_output.json['@fields']['format']).to eq 'application/json'
     end
 
     it "should include the status code" do
       subscriber.process_action(event)
-      log_output.json['@fields']['status'].should == 200
+      expect(log_output.json['@fields']['status']).to eq 200
     end
 
     it "should include the controller" do
       subscriber.process_action(event)
-      log_output.json['@fields']['controller'].should == 'home'
+      expect(log_output.json['@fields']['controller']).to eq 'home'
     end
 
     it "should include the action" do
       subscriber.process_action(event)
-      log_output.json['@fields']['action'].should == 'index'
+      expect(log_output.json['@fields']['action']).to eq 'index'
     end
 
     it "should include the view rendering time" do
       subscriber.process_action(event)
-      log_output.json['@fields']['view'].should == 0.01
+      expect(log_output.json['@fields']['view']).to eq 0.01
     end
 
     it "should include the database rendering time" do
       subscriber.process_action(event)
-      log_output.json['@fields']['db'].should == 0.02
+      expect(log_output.json['@fields']['db']).to eq 0.02
     end
 
     it "should add a valid status when an exception occurred" do
@@ -115,10 +115,10 @@ describe LogStasher::RequestLogSubscriber do
         event.payload[:status] = nil
         event.payload[:exception] = ['AbstractController::ActionNotFound', 'Route not found']
         subscriber.process_action(event)
-        log_output.json['@fields']['status'].should >= 400
-        log_output.json['@fields']['error'].should =~ /AbstractController::ActionNotFound.*Route not found.*logstasher\/spec\/lib\/logstasher\/log_subscriber_spec\.rb/m
-        log_output.json['@tags'].should include 'request'
-        log_output.json['@tags'].should include 'exception'
+        expect(log_output.json['@fields']['status']).to be >= 400
+        expect(log_output.json['@fields']['error']).to be =~ /AbstractController::ActionNotFound.*Route not found.*logstasher\/spec\/lib\/logstasher\/log_subscriber_spec\.rb/m
+        expect(log_output.json['@tags']).to include 'request'
+        expect(log_output.json['@tags']).to include 'exception'
       end
     end
 
@@ -126,7 +126,7 @@ describe LogStasher::RequestLogSubscriber do
       event.payload[:status] = nil
       event.payload[:exception] = nil
       subscriber.process_action(event)
-      log_output.json['@fields']['status'].should == 0
+      expect(log_output.json['@fields']['status']).to eq 0
     end
 
     describe "with a redirect" do
@@ -136,36 +136,36 @@ describe LogStasher::RequestLogSubscriber do
 
       it "should add the location to the log line" do
         subscriber.process_action(event)
-        log_output.json['@fields']['location'].should == 'http://www.example.com'
+        expect(log_output.json['@fields']['location']).to eq 'http://www.example.com'
       end
 
       it "should remove the thread local variable" do
         subscriber.process_action(event)
-        Thread.current[:logstasher_location].should == nil
+        expect(Thread.current[:logstasher_location]).to be_nil
       end
     end
 
     it "should not include a location by default" do
       subscriber.process_action(event)
-      log_output.json['@fields']['location'].should be_nil
+      expect(log_output.json['@fields']['location']).to be_nil
     end
   end
 
   describe "with append_custom_params block specified" do
-    let(:request) { double(:remote_ip => '10.0.0.1')}
+    let(:request) { double(:remote_ip => '10.0.0.1', :env => {})}
     it "should add default custom data to the output" do
-      request.stub(:params => event.payload[:params])
+      allow(request).to receive_messages(:params => event.payload[:params])
       LogStasher.add_default_fields_to_payload(event.payload, request)
       subscriber.process_action(event)
-      log_output.json['@fields']['ip'].should == '10.0.0.1'
-      log_output.json['@fields']['route'].should == 'home#index'
-      log_output.json['@fields']['parameters'].should == {'foo' => 'bar'}
+      expect(log_output.json['@fields']['ip']).to eq '10.0.0.1'
+      expect(log_output.json['@fields']['route']).to eq'home#index'
+      expect(log_output.json['@fields']['parameters']).to eq 'foo' => 'bar'
     end
   end
 
   describe "with append_custom_params block specified" do
     before do
-      LogStasher.stub(:add_custom_fields) do |&block|
+      allow(LogStasher).to receive(:add_custom_fields) do |&block|
         @block = block
       end
       LogStasher.add_custom_fields do |payload|
@@ -177,14 +177,89 @@ describe LogStasher::RequestLogSubscriber do
     it "should add the custom data to the output" do
       @block.call(event.payload)
       subscriber.process_action(event)
-      log_output.json['@fields']['user'].should == 'user'
+      expect(log_output.json['@fields']['user']).to eq 'user'
     end
   end
 
   describe "when processing a redirect" do
     it "should store the location in a thread local variable" do
       subscriber.redirect_to(redirect)
-      Thread.current[:logstasher_location].should == "http://example.com"
+      expect(Thread.current[:logstasher_location]).to eq "http://example.com"
+    end
+  end
+end
+
+describe LogStasher::MailerLogSubscriber do
+  let(:log_output) {StringIO.new}
+  let(:logger) {
+    logger = Logger.new(log_output)
+    logger.formatter = ->(_, _, _, msg) {
+      msg
+    }
+    def log_output.json
+      JSON.parse!(self.string.split("\n").last)
+    end
+    logger
+  }
+
+  before :all do
+    SampleMailer.delivery_method = :test
+    LogStasher::MailerLogSubscriber.attach_to(:action_mailer)
+  end
+
+  before do
+    LogStasher.logger = logger
+    expect(LogStasher.request_context).to receive(:merge).at_most(2).times.and_call_original
+  end
+
+  let :message do
+    Mail.new do
+      from 'some-dude@example.com'
+      to 'some-other-dude@example.com'
+      subject 'Goodbye'
+      body 'LOL'
+    end
+  end
+
+  it 'receive an e-mail' do
+    SampleMailer.receive(message.encoded)
+    log_output.json.tap do |json|
+      expect(json['@source']).to eq(LogStasher.source)
+      expect(json['@tags']).to eq(['mailer', 'receive'])
+      json['@fields'].tap do |fields|
+        expect(fields['mailer']).to eq('SampleMailer')
+        expect(fields['from']).to eq(['some-dude@example.com'])
+        expect(fields['to']).to eq(['some-other-dude@example.com'])
+        expect(fields['message_id']).to eq(message.message_id)
+      end
+    end
+  end
+
+  it 'deliver an outgoing e-mail' do
+    email = SampleMailer.welcome
+
+    if version = ENV['RAILS_VERSION'] and version >= '4.1'
+      log_output.json.tap do |json|
+        expect(json['@source']).to eq(LogStasher.source)
+        expect(json['@tags']).to eq(['mailer', 'process'])
+        json['@fields'].tap do |fields|
+          expect(fields['mailer']).to eq('SampleMailer')
+          expect(fields['action']).to eq('welcome')
+        end
+      end 
+    end
+
+    email.deliver
+    log_output.json.tap do |json|
+      expect(json['@source']).to eq(LogStasher.source)
+      expect(json['@tags']).to eq(['mailer', 'deliver'])
+      json['@fields'].tap do |fields|
+        expect(fields['mailer']).to eq('SampleMailer')
+        expect(fields['from']).to eq(['some-dude@example.com'])
+        expect(fields['to']).to eq(['some-other-dude@example.com'])
+        # Message-Id appears not to be yet available at this point in time.
+        expect(fields['message_id']).to be_nil
+      end
     end
   end
 end

data/spec/lib/logstasher_spec.rb

@@ -5,6 +5,7 @@ describe LogStasher do
     after do
       ActionController::LogSubscriber.attach_to :action_controller
       ActionView::LogSubscriber.attach_to :action_view
+      ActionMailer::LogSubscriber.attach_to :action_mailer
     end
 
     it "should remove subscribers for controller events" do
@@ -23,19 +24,27 @@ describe LogStasher do
       }
     end
 
+    it "should remove subscribsers for mailer events" do
+      expect {
+        LogStasher.remove_existing_log_subscriptions
+      }.to change {
+        ActiveSupport::Notifications.notifier.listeners_for('deliver.action_mailer')
+      }
+    end
+
     it "shouldn't remove subscribers that aren't from Rails" do
       blk = -> {}
       ActiveSupport::Notifications.subscribe("process_action.action_controller", &blk)
       LogStasher.remove_existing_log_subscriptions
       listeners = ActiveSupport::Notifications.notifier.listeners_for('process_action.action_controller')
-      listeners.size.should > 0
+      expect(listeners).to_not be_empty
     end
   end
 
   describe '.appened_default_info_to_payload' do
     let(:params)  { {'a' => '1', 'b' => 2, 'action' => 'action', 'controller' => 'test'}.with_indifferent_access }
     let(:payload) { {:params => params} }
-    let(:request) { double(:params => params, :remote_ip => '10.0.0.1')}
+    let(:request) { double(:params => params, :remote_ip => '10.0.0.1', :env => {})}
     after do
       LogStasher.custom_fields = []
       LogStasher.log_controller_parameters = false
@@ -44,53 +53,75 @@ describe LogStasher do
       LogStasher.log_controller_parameters = true
       LogStasher.custom_fields = []
       LogStasher.add_default_fields_to_payload(payload, request)
-      payload[:ip].should == '10.0.0.1'
-      payload[:route].should == 'test#action'
-      payload[:parameters].should == {'a' => '1', 'b' => 2}
-      LogStasher.custom_fields.should == [:ip, :route, :parameters]
+      expect(payload[:ip]).to eq '10.0.0.1'
+      expect(payload[:route]).to eq 'test#action'
+      expect(payload[:parameters]).to eq 'a' => '1', 'b' => 2
+      expect(LogStasher.custom_fields).to eq [:ip, :route, :request_id, :parameters]
     end
 
     it 'does not include parameters when not configured to' do
       LogStasher.custom_fields = []
       LogStasher.add_default_fields_to_payload(payload, request)
-      payload.should_not have_key(:parameters)
-      LogStasher.custom_fields.should == [:ip, :route]
+      expect(payload).to_not have_key(:parameters)
+      expect(LogStasher.custom_fields).to eq [:ip, :route, :request_id]
     end
   end
 
   describe '.append_custom_params' do
-    let(:block) { ->{} }
+    let(:block) { ->(_, _){} }
     it 'defines a method in ActionController::Base' do
-      ActionController::Base.should_receive(:send).with(:define_method, :logtasher_add_custom_fields_to_payload, &block)
+      expect(ActionController::Base).to receive(:send).with(:define_method, :logtasher_add_custom_fields_to_payload, &block)
       LogStasher.add_custom_fields(&block)
     end
   end
 
+  describe '.add_custom_fields_to_request_context' do
+    let(:block) { ->(_, _){} }
+    it 'defines a method in ActionController::Base' do
+      expect(ActionController::Base).to receive(:send).with(:define_method, :logstasher_add_custom_fields_to_request_context, &block)
+      expect(ActionController::Metal).to receive(:send).with(:define_method, :logstasher_add_custom_fields_to_request_context, &block)
+      LogStasher.add_custom_fields_to_request_context(&block)
+    end
+  end
+
+  describe '.add_default_fields_to_request_context' do
+    it 'adds a request_id to the request context' do
+      LogStasher.clear_request_context
+      LogStasher.add_default_fields_to_request_context(double(env: {'action_dispatch.request_id' => 'lol'}))
+      expect(LogStasher.request_context).to eq({ request_id: 'lol' })
+    end
+  end
+
   shared_examples 'setup' do
-    let(:logger) { double }
-    let(:logstasher_config) { double(:logger => logger, :log_level => 'warn', :log_controller_parameters => nil, :source => logstasher_source) }
+    let(:logstasher_source) { nil }
+    let(:logstasher_config) { double(:logger => logger, :log_level => 'warn', :log_controller_parameters => nil, :source => logstasher_source, :logger_path => logger_path) }
     let(:config) { double(:logstasher => logstasher_config) }
     let(:app) { double(:config => config) }
     before do
       @previous_source = LogStasher.source
-      config.stub(:action_dispatch => double(:rack_cache => false))
+      allow(config).to receive_messages(:action_dispatch => double(:rack_cache => false))
+      allow_message_expectations_on_nil
     end
     after { LogStasher.source = @previous_source } # Need to restore old source for specs
     it 'defines a method in ActionController::Base' do
-      LogStasher.should_receive(:require).with('logstasher/rails_ext/action_controller/metal/instrumentation')
-      LogStasher.should_receive(:require).with('logstash-event')
-      LogStasher.should_receive(:suppress_app_logs).with(app)
-      LogStasher::RequestLogSubscriber.should_receive(:attach_to).with(:action_controller)
-      logger.should_receive(:level=).with('warn')
+      expect(LogStasher).to receive(:require).with('logstasher/rails_ext/action_controller/metal/instrumentation')
+      expect(LogStasher).to receive(:require).with('logstash-event')
+      expect(LogStasher).to receive(:suppress_app_logs).with(app)
+      expect(LogStasher::RequestLogSubscriber).to receive(:attach_to).with(:action_controller)
+      expect(LogStasher::MailerLogSubscriber).to receive(:attach_to).with(:action_mailer)
+      expect(logger).to receive(:level=).with('warn')
       LogStasher.setup(app)
-      LogStasher.source.should == (logstasher_source || 'unknown')
-      LogStasher.enabled.should be_true
-      LogStasher.custom_fields.should == []
-      LogStasher.log_controller_parameters.should == false
+      expect(LogStasher.source).to eq (logstasher_source || 'unknown')
+      expect(LogStasher).to be_enabled
+      expect(LogStasher.custom_fields).to be_empty
+      expect(LogStasher.log_controller_parameters).to eq false
     end
   end
 
   describe '.setup' do
+    let(:logger) { double }
+    let(:logger_path) { nil }
+
     describe 'with source set' do
       let(:logstasher_source) { 'foo' }
       it_behaves_like 'setup'
@@ -100,21 +131,37 @@ describe LogStasher do
       let(:logstasher_source) { nil }
       it_behaves_like 'setup'
     end
+
+    describe 'with customized logging' do
+      let(:logger) { nil }
+
+      context 'with no logger passed in' do
+        before { expect(LogStasher).to receive(:new_logger).with('/log/logstash_test.log') }
+        it_behaves_like 'setup'
+      end
+
+      context 'with custom logger path passed in' do
+        let(:logger_path) { double }
+
+        before { expect(LogStasher).to receive(:new_logger).with(logger_path) }
+        it_behaves_like 'setup'
+      end
+    end
   end
 
   describe '.suppress_app_logs' do
     let(:logstasher_config){ double(:logstasher => double(:suppress_app_log => true))}
     let(:app){ double(:config => logstasher_config)}
     it 'removes existing subscription if enabled' do
-      LogStasher.should_receive(:require).with('logstasher/rails_ext/rack/logger')
-      LogStasher.should_receive(:remove_existing_log_subscriptions)
+      expect(LogStasher).to receive(:require).with('logstasher/rails_ext/rack/logger')
+      expect(LogStasher).to receive(:remove_existing_log_subscriptions)
       LogStasher.suppress_app_logs(app)
     end
 
     context 'when disabled' do
       let(:logstasher_config){ double(:logstasher => double(:suppress_app_log => false)) }
       it 'does not remove existing subscription' do
-        LogStasher.should_not_receive(:remove_existing_log_subscriptions)
+        expect(LogStasher).to_not receive(:remove_existing_log_subscriptions)
         LogStasher.suppress_app_logs(app)
       end
 
@@ -122,7 +169,7 @@ describe LogStasher do
         context 'with spelling "supress_app_log"' do
           let(:logstasher_config){ double(:logstasher => double(:suppress_app_log => nil, :supress_app_log => false)) }
           it 'does not remove existing subscription' do
-            LogStasher.should_not_receive(:remove_existing_log_subscriptions)
+            expect(LogStasher).to_not receive(:remove_existing_log_subscriptions)
             LogStasher.suppress_app_logs(app)
           end
         end
@@ -133,14 +180,14 @@ describe LogStasher do
   describe '.appended_params' do
     it 'returns the stored var in current thread' do
       Thread.current[:logstasher_custom_fields] = :test
-      LogStasher.custom_fields.should == :test
+      expect(LogStasher.custom_fields).to eq :test
     end
   end
 
   describe '.appended_params=' do
     it 'returns the stored var in current thread' do
       LogStasher.custom_fields = :test
-      Thread.current[:logstasher_custom_fields].should == :test
+      expect(Thread.current[:logstasher_custom_fields]).to eq :test
     end
   end
 
@@ -148,11 +195,12 @@ describe LogStasher do
     let(:logger) { double() }
     before do
       LogStasher.logger = logger
-      LogStash::Time.stub(:now => 'timestamp')
+      allow(LogStash::Time).to receive_messages(:now => 'timestamp')
+      allow_message_expectations_on_nil
     end
     it 'adds to log with specified level' do
-      logger.should_receive(:send).with('warn?').and_return(true)
-      logger.should_receive(:send).with('warn',"{\"@source\":\"unknown\",\"@tags\":[\"log\"],\"@fields\":{\"message\":\"WARNING\",\"level\":\"warn\"},\"@timestamp\":\"timestamp\"}")
+      expect(logger).to receive(:send).with('warn?').and_return(true)
+      expect(logger).to receive(:send).with('warn',"{\"@source\":\"unknown\",\"@tags\":[\"log\"],\"@fields\":{\"message\":\"WARNING\",\"level\":\"warn\"},\"@timestamp\":\"timestamp\"}")
       LogStasher.log('warn', 'WARNING')
     end
     context 'with a source specified' do
@@ -160,8 +208,8 @@ describe LogStasher do
         LogStasher.source = 'foo'
       end
       it 'sets the correct source' do
-        logger.should_receive(:send).with('warn?').and_return(true)
-        logger.should_receive(:send).with('warn',"{\"@source\":\"foo\",\"@tags\":[\"log\"],\"@fields\":{\"message\":\"WARNING\",\"level\":\"warn\"},\"@timestamp\":\"timestamp\"}")
+        expect(logger).to receive(:send).with('warn?').and_return(true)
+        expect(logger).to receive(:send).with('warn',"{\"@source\":\"foo\",\"@tags\":[\"log\"],\"@fields\":{\"message\":\"WARNING\",\"level\":\"warn\"},\"@timestamp\":\"timestamp\"}")
         LogStasher.log('warn', 'WARNING')
       end
     end
@@ -171,7 +219,7 @@ describe LogStasher do
     describe ".#{severity}" do
       let(:message) { "This is a #{severity} message" }
       it 'should log with specified level' do
-        LogStasher.should_receive(:log).with(severity.to_sym, message)
+        expect(LogStasher).to receive(:log).with(severity.to_sym, message)
         LogStasher.send(severity, message )
       end
     end
@@ -192,7 +240,7 @@ describe LogStasher do
     before(:each) { LogStasher.custom_fields = [] }
 
     it "subscribes to the required event" do
-      ActiveSupport::Notifications.should_receive(:subscribe).with('event_name')
+      expect(ActiveSupport::Notifications).to receive(:subscribe).with('event_name')
       LogStasher.watch('event_name')
     end
 
@@ -208,7 +256,7 @@ describe LogStasher do
         probe = lambda { |*args, store| store[:foo] = :bar }
         LogStasher.watch('custom.event.bar', &probe)
         ActiveSupport::Notifications.instrument('custom.event.bar', {})
-        LogStasher.store['custom.event.bar'].should == {:foo => :bar}
+        expect(LogStasher.store['custom.event.bar']).to eq :foo => :bar
       end
     end
   end

data/spec/spec_helper.rb

@@ -23,6 +23,8 @@ require 'bundler/setup'
 # part of Rails. You can say :require => false in gemfile to always use explicit requiring
 Bundler.require(:default, :test)
 
+Dir[File.join("./spec/support/**/*.rb")].each { |f| require f }
+
 # Set Rails environment as test
 ENV['RAILS_ENV'] = 'test'
 
@@ -40,11 +42,11 @@ require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/string'
 require 'active_support/core_ext/time/zones'
 require 'abstract_controller/base'
+require 'action_mailer'
 require 'logger'
 require 'logstash-event'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 end

data/spec/support/sample_mailer.rb

@@ -0,0 +1,16 @@
+require 'action_mailer'
+
+class SampleMailer < ActionMailer::Base
+  def welcome
+    mail(from: 'some-dude@example.com', to: 'some-other-dude@example.com', subject: 'Hello, there') do |format|
+      format.text { render plain: 'OK' }
+    end
+  end
+
+  def receive(email)
+  end
+
+  def _render_template(_)
+    ""
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstasher
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Shadab Ahmed
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-06 00:00:00.000000000 Z
+date: 2014-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-event
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -104,9 +104,11 @@ files:
 - logstasher.gemspec
 - sample_logstash_configurations/quickstart.conf
 - spec/lib/logstasher/device/redis_spec.rb
+- spec/lib/logstasher/instrumentation_spec.rb
 - spec/lib/logstasher/log_subscriber_spec.rb
 - spec/lib/logstasher_spec.rb
 - spec/spec_helper.rb
+- spec/support/sample_mailer.rb
 homepage: https://github.com/shadabahmed/logstasher
 licenses: []
 metadata: {}
@@ -126,12 +128,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: logstasher
-rubygems_version: 2.1.4
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Awesome rails logs
 test_files:
 - spec/lib/logstasher/device/redis_spec.rb
+- spec/lib/logstasher/instrumentation_spec.rb
 - spec/lib/logstasher/log_subscriber_spec.rb
 - spec/lib/logstasher_spec.rb
 - spec/spec_helper.rb
+- spec/support/sample_mailer.rb