rv-logstasher 1.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27b875bba60f72b2aeec7c597754ab5a6d72d8a0
+  data.tar.gz: f1102f0c57d2e2c6a79749c5e89314f9698f43e0
+SHA512:
+  metadata.gz: a6ff67002aefae4731beca3b079f08d80d68d5a5acd92bdfed6f775affeacfd79422a53787fd1d46b3a9f8d8c26ed2807396888b8310c2b1a108ae15978eeed2
+  data.tar.gz: 9ff5f5e8f66f6c140375687b641f09c4a1aa24a0b8cfc4f0e92a9d56530a087c725b141adc0acd4a8250c29da29fdd331afa08690473d4d04758c8796a0b0393

data/.gitignore

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

data/.rspec

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

data/.travis.yml

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

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in logstasher.gemspec
+gemspec
+
+group :test do
+  gem 'pry-nav'
+  gem 'rails'
+  gem 'timecop'
+end

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Reevoo Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# Logstasher
+
+**Awesome Logging for Rack applications**
+
+## History
+
+This is a fork of
+[shadabahmed/logstasher](https://github.com/shadabahmed/logstasher). It has
+been updated to use the [latest event
+schema](https://logstash.jira.com/browse/LOGSTASH-675) and customized to better
+fit the needs of Reevoo though it is still generally useful. It is not
+backward compatible with its progenitor.
+
+## Purpose
+
+This gem makes it easy to generate logstash compatible logs for your applications.
+
+A request that looks like this in your `production.log`:
+```text
+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)
+```
+
+Will look like this in your `production.log`:
+```json
+{"tags":["request"],"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","@version":"1"}
+```
+
+From there, it's trivial to forward them to your logstash indexer.
+
+## Installation for Rails Application
+
+In your Gemfile:
+
+    gem 'rv-logstasher'
+
+### Configure your `<environment>.rb` e.g. `development.rb`
+
+    # Enable the logstasher logs for the current environment
+    config.logstasher.enabled = true
+
+    # Optionally silience the standard logging to <environment>.log
+    config.logstasher.silence_standard_logging = true
+
+### Logging params
+
+By default, Logstasher will add params as a JSON encoded string. To disable,
+add the following to your `<environment>.rb`
+
+    # Disable logging of request parameters
+    config.logstasher.include_parameters = false
+
+### Adding custom fields to the log
+
+Since some fields are very specific to your application, e.g., *user_name*,
+it is left upto you to add them. Here's how to do it:
+
+    # Create a file - config/initializers/logstasher.rb
+
+    if LogStasher.enabled
+      LogStasher.append_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'
+      end
+    end
+
+## Installation for Grape Application
+
+### In your Gemfile: 
+
+    gem "rv-logstasher"
+    gem "grape_logging"
+    
+    
+### Init logger:
+    
+    module TestApp
+      def self.logger
+        @logger ||= LogStasher.logger_for_app('app_name', Rack::Directory.new("").root, STDOUT)
+      end
+    end
+
+### Setup Grape request/exception logging
+     
+    module TestApp
+      class API < Grape::API
+        logger TestApp.logger
+        use GrapeLogging::Middleware::RequestLogger, logger: TestApp.logger
+        
+        rescue_from TestApp::NotFound do |err|
+          # Tag your exception 
+          API.logger.info(exception: err, tags: "rescued_exception", status: 404)
+          error_response(message: "Not found", status: 404)
+        end
+
+        rescue_from :all do |e|
+          API.logger.error(e)
+          error_response(message: e.message, status: 500)
+        end
+      end
+    end
+
+
+
+## Copyright
+
+Copyright (c) 2016 Reevoo Ltd, released under the MIT license

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new('spec') do |spec|
+  spec.pattern = "./spec/**/*_spec.rb"
+end
+
+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

data/lib/logstasher.rb

@@ -0,0 +1,75 @@
+require 'logger'
+require 'fileutils'
+require 'logstasher/log_formatter'
+
+module LogStasher
+  class << self
+    attr_reader :append_fields_callback
+    attr_writer :enabled
+    attr_writer :include_parameters
+    attr_writer :serialize_parameters
+    attr_writer :silence_standard_logging
+
+    def append_fields(&block)
+      @append_fields_callback = block
+    end
+
+    def enabled?
+      if @enabled.nil?
+        @enabled = false
+      end
+
+      @enabled
+    end
+
+    def include_parameters?
+      if @include_parameters.nil?
+        @include_parameters = true
+      end
+
+      @include_parameters
+    end
+
+    def serialize_parameters?
+      if @serialize_parameters.nil?
+        @serialize_parameters = true
+      end
+
+      @serialize_parameters
+    end
+
+    def initialize_logger(device = STDOUT, level = ::Logger::INFO, formatter = nil)
+      ::Logger.new(device).tap do |new_logger|
+        new_logger.level = level
+        new_logger.formatter = formatter if formatter
+      end
+    end
+
+    def logger
+      @logger ||= initialize_logger
+    end
+
+    def logger=(log)
+      @logger = log
+    end
+
+    def logger_for_app(app_tag, root_dir = nil, device = nil, level = Logger::INFO)
+      if root_dir && !device
+        device = File.join(root_dir, 'log', 'logstasher.log')
+        FileUtils.touch(device)
+      end
+      formatter = LogFormatter.new(app_tag, root_dir)
+      initialize_logger(device || STDOUT, level, formatter)
+    end
+
+    def silence_standard_logging?
+      if @silence_standard_logging.nil?
+        @silence_standard_logging = false
+      end
+
+      @silence_standard_logging
+    end
+  end
+end
+
+require 'logstasher/railtie' if defined?(Rails)

data/lib/logstasher/context_wrapper.rb

@@ -0,0 +1,14 @@
+module LogStasher
+  module ContextWrapper
+    def process_action(*)
+      Thread.current[:logstasher_context] = {
+        :controller => self,
+        :request    => request
+      }
+
+      super
+    ensure
+      Thread.current[:logstasher_context] = nil
+    end
+  end
+end

data/lib/logstasher/log_formatter.rb

@@ -0,0 +1,63 @@
+module LogStasher
+  class LogFormatter
+    attr_reader :base_tags
+    attr_reader :root_dir
+    attr_reader :release
+
+    def initialize(base_tags = [], root_dir = nil)
+      @base_tags = Array(base_tags)
+      @root_dir = root_dir
+      @release = $1 if root_dir && root_dir =~ /releases\/([^\/]+)/
+    end
+
+    def call(severity, datetime, progname, message)
+      event = {
+        '@timestamp' => datetime.utc,
+        '@version' => '1',
+        severity: severity.downcase,
+      }.merge(format(message))
+
+      event.merge!(format(progname)) if progname.is_a?(Exception)
+      event[:tags] = base_tags + Array(event[:tags])
+      event.to_json + "\n"
+    end
+
+    def format(data)
+      return { message: data } if data.is_a?(String)
+      return format_exception(data) if data.is_a?(Exception)
+      return format_hash(data) if data.is_a?(Hash)
+      fail ArgumentError, "Not expected type of log message: #{data} (#{data.class})"
+    end
+
+    private
+
+    def format_hash(data)
+      data.merge!(request_path: data[:path]) if data[:path] # logstash overrides the path attribute
+      if data[:exception]
+        format_exception(data.delete(:exception)).merge(data)
+      else
+        data
+      end
+    end
+
+    def format_exception(exception)
+      result = {
+        tags: 'exception',
+        error_class: exception.class.to_s,
+        error_message: exception.message,
+        error_source: error_source(exception),
+        error_backtrace: exception.backtrace,
+      }
+
+      if exception.respond_to?(:cause) && exception.cause
+        result[:error_cause] = [exception.cause.class.to_s, exception.cause.message].concat(exception.cause.backtrace)
+      end
+      result
+    end
+
+    def error_source(exception)
+      source = exception.backtrace.find { |line| line.match(/\A#{root_dir}/) }
+      source.sub(/\A#{root_dir}/, '') if source
+    end
+  end
+end

data/lib/logstasher/log_subscriber.rb

@@ -0,0 +1,152 @@
+require 'action_controller/log_subscriber'
+require 'active_support/log_subscriber'
+require 'active_support/core_ext/hash/except'
+require 'json'
+require 'logstash/event'
+
+# active_support monkeypatches Hash#to_json with a version that does not encode
+# time correctly for LogStash. Using JSON.generate bypasses the monkeypatch.
+class LogStash::Event
+  def to_json
+    return JSON.generate(@data)
+  end
+end
+
+module LogStasher
+  class LogSubscriber < ::ActiveSupport::LogSubscriber
+
+    INTERNAL_PARAMS = ::ActionController::LogSubscriber::INTERNAL_PARAMS
+
+    def process_action(event)
+      payload = event.payload
+      tags    = extract_tags(payload)
+      fields  = extract_request(payload)
+
+      fields.merge! extract_status(payload)
+      fields.merge! runtimes(event)
+      fields.merge! location
+      fields.merge! extract_exception(payload)
+      fields.merge! extract_parameters(payload)
+      fields.merge! appended_fields
+
+      event = LogStash::Event.new(fields.merge('tags' => tags))
+
+      LogStasher.logger << event.to_json + "\n"
+    end
+
+    def redirect_to(event)
+      Thread.current[:logstasher_context][:location] = event.payload[:location]
+    end
+
+    private
+
+    def appended_fields
+      callback = ::LogStasher.append_fields_callback
+      {}.tap do |fields|
+        controller.instance_exec(fields, &callback) if callback
+      end
+    end
+
+    def controller
+      Thread.current[:logstasher_context][:controller]
+    end
+
+    def extract_request(payload)
+      {
+        action:         payload[:action],
+        controller:     payload[:controller],
+        format:         extract_format(payload),
+        ip:             request.remote_ip,
+        method:         payload[:method],
+        request_path:   extract_path(payload),
+        route:          "#{payload[:controller]}##{payload[:action]}"
+      }
+    end
+
+    # Monkey patching to enable exception logging
+    def extract_exception(payload)
+      return {} unless payload[:exception]
+
+      exception, message = payload[:exception]
+      status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception)
+      error_source = $!.backtrace.find { |line| line.match(/\A#{Rails.root}/) }
+
+      result = { status: status }
+      result[:error_class] = exception
+      result[:error_message] = message
+      result[:error_source] = error_source.gsub(/\A#{Dir.pwd}/, '') if error_source
+      result[:error_backtrace] = $!.backtrace
+      if $!.respond_to?(:cause) && $!.cause
+        result[:error_cause] = [$!.cause.class.to_s, $!.cause.message].concat($!.cause.backtrace)
+      end
+      result
+    end
+
+    def extract_format(payload)
+      if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0
+        payload[:formats].first
+      else
+        payload[:format]
+      end
+    end
+
+    def extract_parameters(payload)
+      if LogStasher.include_parameters?
+        external_params = payload[:params].except(*INTERNAL_PARAMS)
+
+        if LogStasher.serialize_parameters?
+          { :params => JSON.generate(external_params) }
+        else
+          { :params => external_params }
+        end
+      else
+        {}
+      end
+    end
+
+    def extract_path(payload)
+      payload[:path].split("?").first
+    end
+
+    def extract_status(payload)
+      if payload[:status]
+        { :status => payload[:status].to_i }
+      else
+        { :status => 0 }
+      end
+    end
+
+    def extract_tags(payload)
+      tags = ['request']
+      tags.push('exception') if payload[:exception]
+      tags
+    end
+
+    def location
+      location = Thread.current[:logstasher_context][:location]
+
+      if location
+        { :location => location }
+      else
+        {}
+      end
+    end
+
+    def request
+      Thread.current[:logstasher_context][:request]
+    end
+
+    def runtimes(event)
+      {
+        :total => event.duration,
+        :view  => event.payload[:view_runtime],
+        :db    => event.payload[:db_runtime]
+      }.inject({:runtime => {}}) do |runtimes, (name, runtime)|
+        runtimes[:runtime][name] = runtime.to_f.round(2) if runtime
+        runtimes
+      end
+    end
+  end
+end
+
+::LogStasher::LogSubscriber.attach_to :action_controller

data/lib/logstasher/rack/common_logger_adapter.rb

@@ -0,0 +1,15 @@
+module LogStasher
+  module Rack
+    class CommonLoggerAdapter
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def write(msg)
+        @logger.info(tags: 'rack', message: msg)
+      end
+      
+    end
+  end
+end

data/lib/logstasher/railtie.rb

@@ -0,0 +1,58 @@
+module LogStasher
+  class Railtie < ::Rails::Railtie
+    config.logstasher = ::ActiveSupport::OrderedOptions.new
+    config.logstasher.enabled = false
+    config.logstasher.include_parameters = true
+    config.logstasher.serialize_parameters = true
+    config.logstasher.silence_standard_logging = false
+    config.logstasher.logger = nil
+    config.logstasher.log_level = ::Logger::INFO
+
+    initializer 'logstasher.configure' do
+      options = config.logstasher
+
+      ::LogStasher.enabled                  = options.enabled
+      ::LogStasher.include_parameters       = options.include_parameters
+      ::LogStasher.serialize_parameters     = options.serialize_parameters
+      ::LogStasher.silence_standard_logging = options.silence_standard_logging
+      ::LogStasher.logger                   = options.logger || default_logger
+      ::LogStasher.logger.level             = options.log_level
+    end
+
+    initializer 'logstasher.load' do
+      if ::LogStasher.enabled?
+        ::ActiveSupport.on_load(:action_controller) do
+          require 'logstasher/log_subscriber'
+          require 'logstasher/context_wrapper'
+
+          include ::LogStasher::ContextWrapper
+        end
+      end
+    end
+
+    config.after_initialize do
+      if ::LogStasher.enabled? && ::LogStasher.silence_standard_logging?
+        require 'logstasher/silent_logger'
+
+        ::Rails::Rack::Logger.send(:include, ::LogStasher::SilentLogger)
+
+        ::ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+          if subscriber.is_a?(::ActiveSupport::LogSubscriber)
+            subscriber.class.send(:include, ::LogStasher::SilentLogger)
+          end
+        end
+      end
+    end
+
+    def default_logger
+      unless @default_logger
+        path = ::Rails.root.join('log', "logstasher.log")
+        ::FileUtils.touch(path) # prevent autocreate messages in log
+
+        @default_logger =  ::Logger.new(path)
+      end
+
+      @default_logger
+    end
+  end
+end

data/lib/logstasher/silent_logger.rb

@@ -0,0 +1,16 @@
+module LogStasher
+  module SilentLogger
+    def self.included(klass)
+      klass.class_eval do
+        def logger
+          unless @logstasher_silent_logger
+            @logstasher_silent_logger       = ::Logger.new('/dev/null')
+            @logstasher_silent_logger.level = ::Logger::UNKNOWN
+          end
+
+          @logstasher_silent_logger
+        end
+      end
+    end
+  end
+end

data/lib/logstasher/version.rb

@@ -0,0 +1,3 @@
+module LogStasher
+  VERSION = '1.3.1'
+end

data/lib/rv-logstasher.rb

@@ -0,0 +1 @@
+require 'logstasher'

data/logstasher.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "logstasher/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rv-logstasher"
+  s.version     = LogStasher::VERSION
+  s.authors     = ['David Sevcik', 'Alex Malkov']
+  s.email       = ['david.sevcik@reevoo.com', 'alex.malkov@reevoo.com']
+  s.homepage    = "https://github.com/reevoo/logstasher"
+  s.summary     = %q{Produces log in the logstash format}
+  s.description = %q{Produces log in the logstash format}
+  s.license     = 'MIT'
+
+  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.2"
+
+  s.add_development_dependency "redis"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "pry"
+end

data/spec/lib/logstasher/log_formater_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'logstasher/log_formatter'
+
+describe LogStasher::LogFormatter do
+
+  class TestError < StandardError
+    def cause
+      StandardError.new('Cause error message').tap do |err|
+        err.set_backtrace(['/cause/item1.rb', '/cause/item2.rb'])
+      end
+    end
+  end
+
+  let(:exception_message) { 'Exception message' }
+  let(:exception) do
+    e = TestError.new(exception_message)
+    e.set_backtrace(backtrace)
+    e
+  end
+  let(:backtrace) do
+    [
+      '/foo/bar.rb',
+      '/my/root/releases/12345/foo/broken.rb',
+      '/bar/foo.rb',
+    ]
+  end
+
+  subject { described_class.new('base-tag', '/my/root/releases/12345') }
+
+  describe '#release' do
+    it 'returns indetifier of release from the root dir' do
+      expect(subject.release).to eq('12345')
+    end
+  end
+
+  describe '#format' do
+    context 'with string as an argument' do
+      it 'returns hash with message key' do
+        expect(subject.format('foo')).to eq({ message: 'foo' })
+      end
+    end
+
+    context 'with exception as an argument' do
+
+      it 'returns hash describing the exception' do
+        expect(subject.format(exception)).to match({
+          tags:            'exception',
+          error_class:     'TestError',
+          error_message:   exception_message,
+          error_source:    '/foo/broken.rb',
+          error_backtrace: backtrace,
+          error_cause: [
+            'StandardError',
+            'Cause error message',
+            '/cause/item1.rb',
+            '/cause/item2.rb',
+          ]
+        })
+      end
+    end
+
+    context 'with hash as an argument' do
+      it 'returns hash as it is with path attribute copied to request_path' do
+        # logstash overrides the path attribute
+        expect(subject.format({ foo: 'bar', path: '/my/path' })).to match({
+          foo:          'bar',
+          path:         '/my/path',
+          request_path: '/my/path',
+        })
+      end
+    end
+
+    context 'with hash containing exception key as an argument' do
+      it 'returns hash describing the exception merged with items from origina hash' do
+        expect(subject.format({ exception: exception, tags: 'custom_tag', foo: 'bar' })).to match({
+          tags:            'custom_tag',
+          error_class:     'TestError',
+          error_message:   exception_message,
+          error_source:    '/foo/broken.rb',
+          error_backtrace: backtrace,
+          error_cause:     [
+            'StandardError',
+            'Cause error message',
+            '/cause/item1.rb',
+            '/cause/item2.rb',
+          ],
+          foo:             'bar',
+        })
+      end
+    end
+  end
+
+  describe '#call' do
+    context 'when progname is nil' do
+      let(:progname) { nil }
+
+      it 'returns hash with message key' do
+        result = JSON.parse(subject.call(
+          :error,
+          Time.new(2016, 01, 02, 03, 04, 05),
+          progname,
+          exception_message)).deep_symbolize_keys!
+
+        expect(result).to include({
+          message:  exception_message,
+          severity: "error",
+          tags:     ["base-tag"],
+        })
+
+        expect(result.keys).not_to include(:error_class, :error_message, :error_backtrace, :error_cause)
+      end
+    end
+
+    context 'with progname is an exception' do
+      let(:progname) { exception }
+
+      it 'returns hash describing the exception' do
+        result = JSON.parse(subject.call(
+          :error,
+          Time.new(2016, 01, 02, 03, 04, 05),
+          progname,
+          exception_message)).deep_symbolize_keys!
+
+        expect(result).to include({
+          message:         exception_message,
+          tags:            'exception',
+          error_class:     'TestError',
+          error_message:   exception_message,
+          error_source:    '/foo/broken.rb',
+          error_backtrace: backtrace,
+          error_cause:     [
+            'StandardError',
+            'Cause error message',
+            '/cause/item1.rb',
+            '/cause/item2.rb',
+          ],
+          severity:        "error",
+          tags:            ["base-tag", "exception"],
+
+        })
+      end
+    end
+  end
+end

data/spec/lib/logstasher/log_subscriber_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'securerandom'
+
+require 'logstasher/log_subscriber'
+
+class MockController
+  def user_id
+    @user_id ||= SecureRandom.hex(16)
+  end
+end
+
+class MockRequest
+  def remote_ip
+    '127.0.0.1'
+  end
+end
+
+describe LogStasher::LogSubscriber do
+  subject { described_class.new }
+
+  let(:logger) { ::Logger.new('/dev/null') }
+  let(:mock_controller) { MockController.new }
+  let(:mock_request) { MockRequest.new }
+  let(:context) {{ :controller => mock_controller, :request => mock_request }}
+
+  around do |example|
+    backup_logger = LogStasher.logger
+    LogStasher.logger = logger
+    Thread.current[:logstasher_context] = context
+    Timecop.freeze { example.run }
+    Thread.current[:logstasher_context] = nil
+    LogStasher.logger = backup_logger
+  end
+
+  describe '#process_action' do
+    let(:timestamp) { ::Time.new.utc.iso8601(3) }
+    let(:duration) { 12.4 }
+    let(:json_params) { JSON.dump(payload[:params]) }
+    let(:payload) {{
+      :controller => 'users',
+      :action     => 'show',
+      :params     => { 'foo' => 'bar' },
+      :format     => 'text/plain',
+      :method     => 'method',
+      :path       => '/users/1',
+      :status     => 200
+    }}
+
+    let(:event) { double(:payload => payload, :duration => duration) }
+
+    it 'logs the event in logstash format' do
+      expect(logger).to receive(:<<) do |json|
+        expect(JSON.parse(json)).to eq({
+          '@timestamp'    => timestamp,
+          '@version'      => '1',
+          'tags'          => ['request'],
+          'action'        => payload[:action],
+          'controller'    => payload[:controller],
+          'format'        => payload[:format],
+          'params'        => json_params,
+          'ip'            => mock_request.remote_ip,
+          'method'        => payload[:method],
+          'request_path'  => payload[:path],
+          'route'         => "#{payload[:controller]}##{payload[:action]}",
+          'status'        => payload[:status],
+          'runtime'       => { 'total' => duration }
+        })
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'appends fields to the log' do
+      ::LogStasher.append_fields do |fields|
+        fields['user_id'] = user_id
+        fields['other']   = 'stuff'
+      end
+
+      expect(logger).to receive(:<<) do |json|
+        fields = JSON.parse(json)
+        expect(fields['user_id']).to eq mock_controller.user_id
+        expect(fields['other']).to eq 'stuff'
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'can be configured to remove parameters from the log' do
+      allow(::LogStasher).to receive(:include_parameters?).and_return(false)
+
+      expect(logger).to receive(:<<) do |json|
+        expect(JSON.parse(json)['params']).to be_nil
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'can be configured to skip parameter serialization' do
+      expect(::LogStasher).to receive(:serialize_parameters?).and_return(false)
+
+      expect(logger).to receive(:<<) do |json|
+        expect(JSON.parse(json)['params']).to eq payload[:params]
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'includes redirect location in the log' do
+      redirect_event = double(:payload => {:location => 'new/location'})
+      subject.redirect_to(redirect_event)
+
+      expect(logger).to receive(:<<) do |json|
+        expect(JSON.parse(json)['location']).to eq 'new/location'
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'includes runtimes in the log' do
+      payload.merge!({
+        :view_runtime => 3.3,
+        :db_runtime =>  2.1
+      })
+
+      expect(logger).to receive(:<<) do |json|
+        runtime = JSON.parse(json)['runtime']
+        expect(runtime['view']).to eq 3.3
+        expect(runtime['db']).to eq 2.1
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'includes exception info in the log' do
+      begin
+        fail RuntimeError, 'it no work'
+      rescue
+        # Test inside the rescue block so $! is properly set
+        payload.merge!({
+          :exception => ['RuntimeError', 'it no work']
+        })
+
+        expect(logger).to receive(:<<) do |json|
+          log = JSON.parse(json)
+          expect(log['error_class']).to eq('RuntimeError')
+          expect(log['error_message']).to eq('it no work')
+          expect(log['error_backtrace']).to be_instance_of(Array)
+          expect(log['status']).to eq 500
+          expect(log['tags']).to include('exception')
+        end
+
+        subject.process_action(event)
+      end
+    end
+  end
+
+  describe '#redirect_to' do
+    let(:location) { "users/#{SecureRandom.hex(16)}" }
+    let(:payload) {{ :location => location }}
+    let(:event) { double(:payload => payload) }
+
+    it 'copies the location into the thread local logstasher context' do
+      subject.redirect_to(event)
+      expect(Thread.current[:logstasher_context][:location]).to eq location
+    end
+  end
+end

data/spec/lib/logstasher/railtie_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+require 'action_controller/railtie'
+require 'action_controller/log_subscriber'
+require 'action_view/railtie'
+require 'action_view/log_subscriber'
+
+require 'logstasher/context_wrapper'
+require 'logstasher/log_subscriber'
+require 'logstasher/railtie'
+require 'logstasher/silent_logger'
+
+ENV['RAILS_ENV'] = 'test'
+
+class ::LogStasher::RailtieApp < ::Rails::Application
+end
+
+describe ::LogStasher::Railtie do
+  let(:config) { described_class.config.logstasher }
+
+  describe 'logstasher.configure' do
+    subject do
+      described_class.instance.initializers.find do |initializer|
+        initializer.name == 'logstasher.configure'
+      end
+    end
+
+    it 'should configure LogStasher' do
+      config.logger                   = ::Logger.new('/dev/null')
+      config.log_level                = "log_level"
+      config.enabled                  = "enabled"
+      config.include_parameters       = "include_parameters"
+      config.serialize_parameters     = "serialize_parameters"
+      config.silence_standard_logging = "silence_standard_logging"
+
+      expect(::LogStasher).to receive(:enabled=).with("enabled")
+      expect(::LogStasher).to receive(:include_parameters=).with("include_parameters")
+      expect(::LogStasher).to receive(:serialize_parameters=).with("serialize_parameters")
+      expect(::LogStasher).to receive(:silence_standard_logging=).with("silence_standard_logging")
+      expect(::LogStasher).to receive(:logger=).with(config.logger).and_call_original
+      expect(config.logger).to receive(:level=).with("log_level")
+
+      subject.run
+    end
+  end
+
+  describe 'logstasher.load' do
+    subject do
+      described_class.instance.initializers.find do |initializer|
+        initializer.name == 'logstasher.load'
+      end
+    end
+
+    context 'when logstasher is disabled' do
+      it 'does nothing' do
+        expect(::ActiveSupport).not_to receive(:on_load)
+
+        subject.run
+      end
+    end
+
+    context 'when logstasher is enabled' do
+      before { allow(::LogStasher).to receive(:enabled?) { true } }
+
+      it 'should load LogStasher into ActionController' do
+        expect(::ActionController).to receive(:require).with('logstasher/log_subscriber')
+        expect(::ActionController).to receive(:require).with('logstasher/context_wrapper')
+        expect(::ActionController).to receive(:include).with(::LogStasher::ContextWrapper)
+
+        subject.run
+        ::ActiveSupport.run_load_hooks(:action_controller, ::ActionController)
+      end
+    end
+  end
+
+  describe 'config.after_initialize' do
+    context 'when logstasher is enabled' do
+      before { allow(::LogStasher).to receive(:enabled?) { true } }
+
+      context 'and silence_standard_logging is enabled' do
+        before { allow(::LogStasher).to receive(:silence_standard_logging?) { true } }
+
+        it 'should not silence standard logging' do
+          expect(::ActionController::LogSubscriber).to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::ActionView::LogSubscriber).to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::Rails::Rack::Logger).to receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+
+      context 'and silence_standard_logging is disabled' do
+        before { allow(::LogStasher).to receive(:silence_standard_logging?) { false } }
+
+        it 'should not silence standard logging' do
+          expect(::ActionController).not_to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::ActionView).not_to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::Rails::Rack::Logger).not_to receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+    end
+
+    context 'when logstasher is disabled' do
+      before { allow(::LogStasher).to receive(:enabled?) { false } }
+
+      context 'and silence_standard_logging is enabled' do
+        before { allow(::LogStasher).to receive(:silence_standard_logging?) { true } }
+
+        it 'should not silence standard logging' do
+          expect(::ActionController::LogSubscriber).not_to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::ActionView::LogSubscriber).not_to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::Rails::Rack::Logger).not_to receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+
+      context 'and silence_standard_logging is disabled' do
+        before { allow(::LogStasher).to receive(:silence_standard_logging?) { false } }
+
+        it 'should not silence standard logging' do
+          expect(::ActionController).not_to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::ActionView).not_to receive(:include).with(::LogStasher::SilentLogger)
+          expect(::Rails::Rack::Logger).not_to receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+    end
+  end
+end

data/spec/lib/logstasher_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe LogStasher do
+  it 'has a version' do
+    expect(::LogStasher::VERSION).not_to be_nil
+  end
+
+  it 'has a logger' do
+    expect(::LogStasher.logger).to be_a_kind_of(::Logger)
+  end
+
+  it 'stores a callback for appending fields' do
+    callback = proc { |fields| fail 'Did not expect this to run'  }
+
+    ::LogStasher.append_fields(&callback)
+    expect(::LogStasher.append_fields_callback).to be callback
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# Notice there is a .rspec file in the root folder. It defines rspec arguments
+
+# Modify load path so you can require logstasher directly.
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+require 'bundler/setup'
+
+Bundler.require(:default, :development, :test)
+
+require 'logstasher'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: rv-logstasher
+version: !ruby/object:Gem::Version
+  version: 1.3.1
+platform: ruby
+authors:
+- David Sevcik
+- Alex Malkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logstash-event
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Produces log in the logstash format
+email:
+- david.sevcik@reevoo.com
+- alex.malkov@reevoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/logstasher.rb
+- lib/logstasher/context_wrapper.rb
+- lib/logstasher/log_formatter.rb
+- lib/logstasher/log_subscriber.rb
+- lib/logstasher/rack/common_logger_adapter.rb
+- lib/logstasher/railtie.rb
+- lib/logstasher/silent_logger.rb
+- lib/logstasher/version.rb
+- lib/rv-logstasher.rb
+- log/logstash_development.log
+- log/logstash_test.log
+- log/test.log
+- logstasher.gemspec
+- spec/lib/logstasher/log_formater_spec.rb
+- spec/lib/logstasher/log_subscriber_spec.rb
+- spec/lib/logstasher/railtie_spec.rb
+- spec/lib/logstasher_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/reevoo/logstasher
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Produces log in the logstash format
+test_files:
+- spec/lib/logstasher/log_formater_spec.rb
+- spec/lib/logstasher/log_subscriber_spec.rb
+- spec/lib/logstasher/railtie_spec.rb
+- spec/lib/logstasher_spec.rb
+- spec/spec_helper.rb