logstasher 0.6.0 → 0.6.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MmUyOWU0M2UwMGY1YzRjZDU0ZDRmNGExM2E2YTZjZDVhMGEyYWRjMQ==
+    YjJhNTIyM2IxMDc5NDU0ZmZjZTNlMzhlZTg1MTRkNzE4NDNkMDQ2OQ==
   data.tar.gz: !binary |-
-    NGI2M2M3NGNjYjc2OGZjMWI0NGU3MTM3ZjljMDY5ZGNhYTk5OTYxNQ==
+    OWI5OTI4ZDUzYThmMTM3NGJjNjUzY2VhYTc3ZTcwNWExMzFhNzdhZg==
 SHA512:
   metadata.gz: !binary |-
-    YjM5YzhmMGU0YTcyYTAxMWMxYzAxZWE5NTgyN2RmYTM3MWM0ZDE0MTY1YWQ2
-    YzIzOWQ4MjFkODA0NDMwNDk3YWY4MmNkYzY1M2ViNmU4NjZmYzdjMDZlMGU2
-    ZGM2MGY0ZmNjYzk3NTYwODRiMTc3ZDg1OTYzZWFiMTgzNmEyZjA=
+    Y2FlMTgzZGMxMjk3MDFmOTE2NzM4YTc4ZjJmNTgwMGFmZmVhMTYyYzk5ZjM3
+    YzM1NDVlYjUxYWM5ZGE4OTJkOWU0ZTgxZjEzMWJlNGZhZTYxMzk0NDcxNTJl
+    MDcwMjgzMDQ0NTVmODVhYTEwZDE2ODFiNWJkYTg5NTgwYTMzYmM=
   data.tar.gz: !binary |-
-    NTk2MDFmNGM4MDFlOGE2OGI1NjE3MDMwZmZmYjRlZTM0NDQwMTU1OGZiMzBl
-    N2VlYzViNzQ2MDFjODk4OWYyYThhZGRjNzUyMDRhNzBiZjU3YTdhM2E0ZjJj
-    ZTRlYTA2Y2UyM2UzN2M0YTY5MDFkY2IyNzk1NmY5MzM5MjJlOGQ=
+    N2E4ZGM1NzU4MTIwZjZlM2RiNzY1NDhiMzE0ZjY1Yjg1YTQxMjA4YTcxNzMx
+    NmEwNTQwZWY0ODYxYzBmNzEwNzZlMDNlZTVkZjExYjlhZjRmYTY1YzcyNzVk
+    YzFhOTQwY2FhNjlkNmVkYzAyYmU0ZGE5ZDYxODI2OTJhYmQwNmM=

data/lib/logstasher/log_subscriber.rb

@@ -109,7 +109,12 @@ module LogStasher
       process_event(event, ['mailer', 'process'])
     end
 
+    def logger
+      LogStasher.logger
+    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)
@@ -119,9 +124,5 @@ module LogStasher
     def extract_metadata(payload)
       payload.slice(*MAILER_FIELDS)
     end
-
-    def logger
-      LogStasher.logger
-    end
   end
 end

data/lib/logstasher/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstasher
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Shadab Ahmed
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-event
@@ -87,13 +87,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
-- Gemfile
-- Guardfile
-- README.md
-- Rakefile
 - lib/logstasher.rb
 - lib/logstasher/device/redis.rb
 - lib/logstasher/log_subscriber.rb
@@ -101,16 +94,9 @@ files:
 - lib/logstasher/rails_ext/rack/logger.rb
 - lib/logstasher/railtie.rb
 - lib/logstasher/version.rb
-- 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: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -127,15 +113,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: logstasher
+rubyforge_project: 
 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
+test_files: []

data/.gitignore

@@ -1,5 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
-.idea

data/.rspec

@@ -1,2 +0,0 @@
---color
---format progress

data/.travis.yml

@@ -1,12 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-
-env:
-  - "RAILS_VERSION=4.0"
-  - "RAILS_VERSION=3.2"
-  - "RAILS_VERSION=3.1"
-  - "RAILS_VERSION=3.0"
-
-script: bundle exec rspec

data/Gemfile

@@ -1,15 +0,0 @@
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in logstasher.gemspec
-gemspec
-
-group :test do
-  gem 'growl'
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'rails', "~> #{ENV["RAILS_VERSION"] || "3.2.0"}"
-  gem 'rb-fsevent', '~> 0.9'
-  gem 'rcov', :platforms => :mri_18
-  gem 'redis', :require => false
-  gem 'simplecov', :platforms => :mri_19, :require => false
-end

data/Guardfile

@@ -1,10 +0,0 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-interactor :simple
-
-guard 'rspec', :version => 2 do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-end
-

data/README.md

@@ -1,162 +0,0 @@
-# Logstasher [![Gem Version](https://badge.fury.io/rb/logstasher.png)](http://badge.fury.io/rb/logstasher) [![Build Status](https://secure.travis-ci.org/shadabahmed/logstasher.png)](https://secure.travis-ci.org/shadabahmed/logstasher)
-### Awesome Logging for Rails !!
-
-This gem is heavily inspired from [lograge](https://github.com/roidrage/lograge), but it's focused on one thing and one thing only. That's making your logs awesome like this:
-
-[![Awesome Logs](https://f.cloud.github.com/assets/830679/2407078/dcde03e8-aa82-11e3-85ac-8c5b3a86676e.png)](https://f.cloud.github.com/assets/830679/2407078/dcde03e8-aa82-11e3-85ac-8c5b3a86676e.png)
-
-How it's done ?
-
-By, using these awesome tools:
-* [Logstash](http://logstash.net) - Store and index your logs
-* [Kibana](http://kibana.org/) - for awesome visualization. This is optional though, and you can use any other visualizer
-
-Update: Logstash now includes Kibana build in, so no need to separately install. Logstasher has been test with **logstash version 1.3.3**
-
-See [quickstart](#quick-setup-for-logstash) for quickly setting up logstash
-
-## About logstasher
-
-This gem purely focuses on how to generate logstash compatible logs i.e. *logstash json event format*,  without any overhead. Infact, logstasher logs to a separate log file named `logstash_<environment>.log`.
-The reason for this separation:
- * To have a pure json log file
- * Prevent any logger messages(e.g. info) getting into our pure json logs
-
-Before **logstasher** :
-
-```
-Started GET "/login" for 10.109.10.135 at 2013-04-30 08:59:01 -0400
-Processing by SessionsController#new as HTML
-  Rendered sessions/new.html.haml within layouts/application (4.3ms)
-  Rendered shared/_javascript.html.haml (0.6ms)
-  Rendered shared/_flashes.html.haml (0.2ms)
-  Rendered shared/_header.html.haml (52.9ms)
-  Rendered shared/_title.html.haml (0.2ms)
-  Rendered shared/_footer.html.haml (0.2ms)
-Completed 200 OK in 532ms (Views: 62.4ms | ActiveRecord: 0.0ms | ND API: 0.0ms)
-```
-
-After **logstasher**:
-
-```
-{"@source":"unknown","@tags":["request"],"@fields":{"method":"GET","path":"/","format":"html","controller":"file_servers"
-,"action":"index","status":200,"duration":28.34,"view":25.96,"db":0.88,"ip":"127.0.0.1","route":"file_servers#index",
-"parameters":"","ndapi_time":null,"uuid":"e81ecd178ed3b591099f4d489760dfb6","user":"shadab_ahmed@abc.com",
-"site":"internal"},"@timestamp":"2013-04-30T13:00:46.354500+00:00"}
-```
-
-By default, the older format rails request logs are disabled, though you can enable them.
-
-## Installation
-
-In your Gemfile:
-
-    gem 'logstasher'
-
-### Configure your `<environment>.rb` e.g. `development.rb`
-
-    # Enable the logstasher logs for the current environment
-    config.logstasher.enabled = true
-
-    # This line is optional if you do not want to suppress app logs in your <environment>.log
-    config.logstasher.suppress_app_log = false
-
-    # This line is optional, it allows you to set a custom value for the @source field of the log event
-    config.logstasher.source = 'your.arbitrary.source'
-
-## Logging params hash
-
-Logstasher can be configured to log the contents of the params hash.  When enabled, the contents of the params hash (minus the ActionController internal params)
-will be added to the log as a deep hash.  This can cause conflicts within the Elasticsearch mappings though, so should be enabled with care.  Conflicts will occur
-if different actions (or even different applications logging to the same Elasticsearch cluster) use the same params key, but with a different data type (e.g. a
-string vs. a hash).  This can lead to lost log entries.  Enabling this can also significantly increase the size of the Elasticsearch indexes.
-
-To enable this, add the following to your `<environment>.rb`
-
-    # Enable logging of controller params
-    config.logstasher.log_controller_parameters = true
-
-## Adding custom fields to the log
-
-Since some fields are very specific to your application for e.g. *user_name*, so it is left upto you, to add them. Here's how to add those fields to the logs:
-
-    # Create a file - config/initializers/logstasher.rb
-
-    if LogStasher.enabled
-      LogStasher.add_custom_fields do |fields|
-        # This block is run in application_controller context,
-        # so you have access to all controller methods
-        fields[:user] = current_user && current_user.mail
-        fields[:site] = request.path =~ /^\/api/ ? 'api' : 'user'
-
-        # If you are using custom instrumentation, just add it to logstasher custom fields
-        LogStasher.custom_fields << :myapi_runtime
-      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:
-
-    # In config/initializers/logstasher.rb
-
-    # Watch calls the block with the same arguments than any ActiveSupport::Notification, plus a store
-    LogStasher.watch('some.activesupport.notification') do |name, start, finish, id, payload, store|
-      # Do something
-      store[:count] = 42
-    end
-
-Would change the log entry to:
-
-```
-{"@source":"unknown","@tags":["request"],"@fields":{"method":"GET","path":"/","format":"html","controller":"file_servers","action":"index","status":200,"duration":28.34,"view":25.96,"db":0.88,"ip":"127.0.0.1","route":"file_servers#index", "parameters":"","ndapi_time":null,"uuid":"e81ecd178ed3b591099f4d489760dfb6","user":"shadab_ahmed@abc.com", "site":"internal","some.activesupport.notification":{"count":42}},"@timestamp":"2013-04-30T13:00:46.354500+00:00"}
-```
-
-The store exposed to the blocked passed to `watch` is thread-safe, and reset after each request.
-By default, the store is only shared between occurences of the same event.
-You can easily share the same store between different types of notifications, by assigning them to the same event group:
-
-    # In config/initializers/logstasher.rb
-
-    LogStasher.watch('foo.notification', event_group: 'notification') do |*args, store|
-      # Shared store with 'bar.notification'
-    end
-
-    LogStasher.watch('bar.notification', event_group: 'notification') do |*args, store|
-      # Shared store with 'foo.notification'
-    end
-
-## Quick Setup for Logstash
-
-* Download logstash from [logstash.net](http://www.logstash.net/)
-* Use this sample config file: [quickstart.conf](https://github.com/shadabahmed/logstasher/raw/master/sample_logstash_configurations/quickstart.conf)
-* Start logstash with the following command:
-```
-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.)
-
-## Versions
-All versions require Rails 3.0.x and higher and Ruby 1.9.2+. Tested on Rails 4 and Ruby 2.0
-
-## Development
- - Run tests - `rake`
- - Generate test coverage report - `rake coverage`. Coverage report path - coverage/index.html
-
-## Copyright
-
-Copyright (c) 2013 Shadab Ahmed, released under the MIT license
-
-
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/shadabahmed/logstasher/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
-

data/Rakefile

@@ -1,50 +0,0 @@
-require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
-
-# Add default task. When you type just rake command this would run. Travis CI runs this. Making this run spec
-desc 'Default: run specs.'
-task :default => :spec
-
-# Defining spec task for running spec
-desc "Run specs"
-RSpec::Core::RakeTask.new('spec') do |spec|
-  # Pattern filr for spec files to run. This is default btw.
-  spec.pattern = "./spec/**/*_spec.rb"
-end
-
-# Run the rdoc task to generate rdocs for this gem
-require 'rdoc/task'
-RDoc::Task.new do |rdoc|
-  require "logstasher/version"
-  version = LogStasher::VERSION
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "logstasher #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-# Code coverage tasks. Different for Ruby 1.8 vs 1.9
-if RUBY_VERSION =~ /^1\.8/
-  # Ruby 1.8 uses rcov for code coverage
-  RSpec::Core::RakeTask.new(:coverage) do |spec|
-    spec.pattern = 'spec/**/*_spec.rb'
-    spec.rcov = true
-    spec.rcov_opts = %w{--exclude pkg\/,spec\/,features\/}
-  end
-else
-  # Ruby 1.9+ using simplecov. Note: Simplecov config defined in spec_helper
-  desc "Code coverage detail"
-  task :coverage do
-    ENV['COVERAGE'] = "true"
-    Rake::Task['spec'].execute
-  end
-end
-
-task :console do
-  require 'irb'
-  require 'irb/completion'
-  require 'logstasher'
-  ARGV.clear
-  IRB.start
-end

data/logstasher.gemspec

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "logstasher/version"
-
-Gem::Specification.new do |s|
-  s.name        = "logstasher"
-  s.version     = LogStasher::VERSION
-  s.authors     = ["Shadab Ahmed"]
-  s.email       = ["shadab.ansari@gmail.com"]
-  s.homepage    = "https://github.com/shadabahmed/logstasher"
-  s.summary     = %q{Awesome rails logs}
-  s.description = %q{Awesome rails logs}
-
-  s.rubyforge_project = "logstasher"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.add_runtime_dependency "logstash-event", ["~> 1.1.0"]
-  s.add_runtime_dependency "request_store"
-
-  # specify any dependencies here; for example:
-  s.add_development_dependency "rspec", [">= 2.14"]
-  s.add_development_dependency("bundler", [">= 1.0.0"])
-  s.add_development_dependency("rails", [">= 3.0"])
-end

data/sample_logstash_configurations/quickstart.conf

@@ -1,23 +0,0 @@
-input {
-  file { 
-    type => "rails logs"
-    path => "/Users/shadab/test_project/logstash_development.log"
-    codec =>   json {
-      charset => "UTF-8"
-    }
-  } 
-}
-
-output {
-  # Print each event to stdout.
-  stdout {
-    codec => rubydebug
-  }
-  
-  elasticsearch {
-    # Setting 'embedded' will run  a real elasticsearch server inside logstash.
-    # This option below saves you from having to run a separate process just
-    # for ElasticSearch, so you can get started quicker!
-    embedded => true
-  }
-}

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

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-require 'logstasher/device/redis'
-
-describe LogStasher::Device::Redis do
-
-  let(:redis_mock) { double('Redis') }
-
-  let(:default_options) {{
-    key: 'logstash',
-    data_type: 'list'
-  }}
-
-  it 'has default options' do
-    device = LogStasher::Device::Redis.new
-    expect(device.options).to eq(default_options)
-  end
-
-  it 'creates a redis instance' do
-    expect(::Redis).to receive(:new).with({})
-    LogStasher::Device::Redis.new()
-  end
-
-  it 'assumes unknown options are for redis' do
-    expect(::Redis).to receive(:new).with(hash_including(db: '0'))
-    device = LogStasher::Device::Redis.new(db: '0')
-    expect(device.redis_options).to eq(db: '0')
-  end
-
-  it 'has a key' do
-    device = LogStasher::Device::Redis.new(key: 'the_key')
-    expect(device.key).to eq('the_key')
-  end
-
-  it 'has a data_type' do
-    device = LogStasher::Device::Redis.new(data_type: 'channel')
-    expect(device.data_type).to eq('channel')
-  end
-
-  it 'does not allow unsupported data types' do
-    expect {
-      device = LogStasher::Device::Redis.new(data_type: 'blargh')
-    }.to raise_error()
-  end
-
-  it 'quits the redis connection on #close' do
-    device = LogStasher::Device::Redis.new
-    expect(device.redis).to receive(:quit)
-    device.close
-  end
-
-  it 'works as a logger device' do
-    device = LogStasher::Device::Redis.new
-    expect(device).to receive(:write).with('blargh')
-    logger = Logger.new(device)
-    logger << 'blargh'
-  end
-
-  describe '#write' do
-    it "rpushes logs onto a list" do
-      device = LogStasher::Device::Redis.new(data_type: 'list')
-      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')
-      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')
-      expect(device.redis).to receive(:publish).with('custom', 'the log')
-      device.write('the log')
-    end
-  end
-
-end

data/spec/lib/logstasher/instrumentation_spec.rb

@@ -1,62 +0,0 @@
-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

@@ -1,265 +0,0 @@
-require 'spec_helper'
-
-describe LogStasher::RequestLogSubscriber 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
-    end
-    logger
-  }
-  before do
-    LogStasher.logger = logger
-    LogStasher.log_controller_parameters = true
-    LogStasher.custom_fields = []
-  end
-  after do
-    LogStasher.log_controller_parameters = false
-  end
-
-  let(:subscriber) {LogStasher::RequestLogSubscriber.new}
-  let(:event) {
-    ActiveSupport::Notifications::Event.new(
-      'process_action.action_controller', Time.now, Time.now, 2, {
-        status: 200, format: 'application/json', method: 'GET', path: '/home?foo=bar', params: {
-          :controller => 'home', :action => 'index', 'foo' => 'bar'
-        }.with_indifferent_access, db_runtime: 0.02, view_runtime: 0.01
-      }
-    )
-  }
-
-  let(:redirect) {
-    ActiveSupport::Notifications::Event.new(
-      'redirect_to.action_controller', Time.now, Time.now, 1, location: 'http://example.com', status: 302
-    )
-  }
-
-  describe '.process_action' do
-    let!(:request_subscriber) { @request_subscriber ||= LogStasher::RequestLogSubscriber.new() }
-    let(:payload) { {} }
-    let(:event)   { double(:payload => payload) }
-    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
-      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
-      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
-
-  describe 'logstasher output' do
-
-    it "should contain request tag" do
-      subscriber.process_action(event)
-      expect(log_output.json['@tags']).to include 'request'
-    end
-
-    it "should contain HTTP method" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['method']).to eq 'GET'
-    end
-
-    it "should include the path in the log output" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['path']).to eq '/home'
-    end
-
-    it "should include the format in the log output" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['format']).to eq 'application/json'
-    end
-
-    it "should include the status code" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['status']).to eq 200
-    end
-
-    it "should include the controller" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['controller']).to eq 'home'
-    end
-
-    it "should include the action" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['action']).to eq 'index'
-    end
-
-    it "should include the view rendering time" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['view']).to eq 0.01
-    end
-
-    it "should include the database rendering time" do
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['db']).to eq 0.02
-    end
-
-    it "should add a valid status when an exception occurred" do
-      begin
-        raise AbstractController::ActionNotFound.new('Could not find an action')
-      # working this in rescue to get access to $! variable
-      rescue
-        event.payload[:status] = nil
-        event.payload[:exception] = ['AbstractController::ActionNotFound', 'Route not found']
-        subscriber.process_action(event)
-        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
-
-    it "should return an unknown status when no status or exception is found" do
-      event.payload[:status] = nil
-      event.payload[:exception] = nil
-      subscriber.process_action(event)
-      expect(log_output.json['@fields']['status']).to eq 0
-    end
-
-    describe "with a redirect" do
-      before do
-        Thread.current[:logstasher_location] = "http://www.example.com"
-      end
-
-      it "should add the location to the log line" do
-        subscriber.process_action(event)
-        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)
-        expect(Thread.current[:logstasher_location]).to be_nil
-      end
-    end
-
-    it "should not include a location by default" do
-      subscriber.process_action(event)
-      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', :env => {})}
-    it "should add default custom data to the output" do
-      allow(request).to receive_messages(:params => event.payload[:params])
-      LogStasher.add_default_fields_to_payload(event.payload, request)
-      subscriber.process_action(event)
-      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
-      allow(LogStasher).to receive(:add_custom_fields) do |&block|
-        @block = block
-      end
-      LogStasher.add_custom_fields do |payload|
-        payload[:user] = 'user'
-      end
-      LogStasher.custom_fields += [:user]
-    end
-
-    it "should add the custom data to the output" do
-      @block.call(event.payload)
-      subscriber.process_action(event)
-      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)
-      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

@@ -1,263 +0,0 @@
-require 'spec_helper'
-
-describe LogStasher do
-  describe "when removing Rails' log subscribers" 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
-      expect {
-        LogStasher.remove_existing_log_subscriptions
-      }.to change {
-        ActiveSupport::Notifications.notifier.listeners_for('process_action.action_controller')
-      }
-    end
-
-    it "should remove subscribers for all events" do
-      expect {
-        LogStasher.remove_existing_log_subscriptions
-      }.to change {
-        ActiveSupport::Notifications.notifier.listeners_for('render_template.action_view')
-      }
-    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')
-      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', :env => {})}
-    after do
-      LogStasher.custom_fields = []
-      LogStasher.log_controller_parameters = false
-    end
-    it 'appends default parameters to payload' do
-      LogStasher.log_controller_parameters = true
-      LogStasher.custom_fields = []
-      LogStasher.add_default_fields_to_payload(payload, request)
-      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)
-      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) { ->(_, _){} }
-    it 'defines a method in ActionController::Base' do
-      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(: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
-      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
-      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)
-      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'
-    end
-
-    describe 'without source set (default behaviour)' 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
-      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
-        expect(LogStasher).to_not receive(:remove_existing_log_subscriptions)
-        LogStasher.suppress_app_logs(app)
-      end
-
-      describe "backward compatibility" 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
-            expect(LogStasher).to_not receive(:remove_existing_log_subscriptions)
-            LogStasher.suppress_app_logs(app)
-          end
-        end
-      end
-    end
-  end
-
-  describe '.appended_params' do
-    it 'returns the stored var in current thread' do
-      Thread.current[:logstasher_custom_fields] = :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
-      expect(Thread.current[:logstasher_custom_fields]).to eq :test
-    end
-  end
-
-  describe '.log' do
-    let(:logger) { double() }
-    before do
-      LogStasher.logger = logger
-      allow(LogStash::Time).to receive_messages(:now => 'timestamp')
-      allow_message_expectations_on_nil
-    end
-    it 'adds to log with specified level' do
-      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
-      before :each do
-        LogStasher.source = 'foo'
-      end
-      it 'sets the correct source' do
-        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
-  end
-
-  %w( fatal error warn info debug unknown ).each do |severity|
-    describe ".#{severity}" do
-      let(:message) { "This is a #{severity} message" }
-      it 'should log with specified level' do
-        expect(LogStasher).to receive(:log).with(severity.to_sym, message)
-        LogStasher.send(severity, message )
-      end
-    end
-  end
-
-  describe '.store' do
-    it "returns a new Hash for each key" do
-      expect(LogStasher.store['a'].object_id).to_not be(LogStasher.store['b'].object_id)
-    end
-
-    it "returns the same store if called several time with the same key" do
-      expect(LogStasher.store['a'].object_id).to be(LogStasher.store['a'].object_id)
-    end
-
-  end
-
-  describe ".watch" do
-    before(:each) { LogStasher.custom_fields = [] }
-
-    it "subscribes to the required event" do
-      expect(ActiveSupport::Notifications).to receive(:subscribe).with('event_name')
-      LogStasher.watch('event_name')
-    end
-
-    it 'executes the block when receiving an event' do
-      probe = lambda {}
-      LogStasher.watch('custom.event.foo', &probe)
-      expect(probe).to receive(:call)
-      ActiveSupport::Notifications.instrument('custom.event.foo', {})
-    end
-
-    describe "store" do
-      it 'stores the events in a store with the event\'s name' do
-        probe = lambda { |*args, store| store[:foo] = :bar }
-        LogStasher.watch('custom.event.bar', &probe)
-        ActiveSupport::Notifications.instrument('custom.event.bar', {})
-        expect(LogStasher.store['custom.event.bar']).to eq :foo => :bar
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,52 +0,0 @@
-# Notice there is a .rspec file in the root folder. It defines rspec arguments
-
-# Ruby 1.9 uses simplecov. The ENV['COVERAGE'] is set when rake coverage is run in ruby 1.9
-if ENV['COVERAGE']
-  require 'simplecov'
-  SimpleCov.start do
-    # Remove the spec folder from coverage. By default all code files are included. For more config options see
-    # https://github.com/colszowka/simplecov
-    add_filter File.expand_path('../../spec', __FILE__)
-  end
-end
-
-# Modify load path so you can require 'ogstasher directly.
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-
-require 'rubygems'
-# Loads bundler setup tasks. Now if I run spec without installing gems then it would say gem not installed and
-# do bundle install instead of ugly load error on require.
-require 'bundler/setup'
-
-# This will require me all the gems automatically for the groups. If I do only .setup then I will have to require gems
-# manually. Note that you have still have to require some gems if they are part of bigger gem like ActiveRecord which is
-# 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'
-
-require 'action_pack'
-require 'action_controller'
-require 'logstasher'
-require 'active_support/notifications'
-require 'active_support/core_ext/string'
-require 'active_support/log_subscriber'
-require 'action_controller/log_subscriber'
-require 'action_view/log_subscriber'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/indifferent_access'
-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.run_all_when_everything_filtered = true
-  config.filter_run :focus
-end

data/spec/support/sample_mailer.rb

@@ -1,16 +0,0 @@
-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