md-logstasher 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08fdc83eeea6e130441ff8d5f6a66a25d0a88565
+  data.tar.gz: 9d19f05f78e5b099647e5102d17e3a9f456c580b
+SHA512:
+  metadata.gz: a0cfeefec296db67e6f1ca2b66d5eadb59a68ca272d3858afb03db7c95a9e57a0e69e4411efffc0044b90fd2e3e9b43c71e7d71e2307511e849a9f55bd7d9e8d
+  data.tar.gz: 458feac68319ae244968c182c66b15811556d6368d9d8b0c82a07c1dff4c557bdd0b458e63e276fc709f0afa3fe049ac88fc2bf4fe6a6b85fafbde5a56de5b1a

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) 2014 Shadab Ahmed
+
+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,90 @@
+# Logstasher
+
+**Awesome Logging for Rails**
+
+## 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 MoneyDesktop--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 rails app.
+
+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 `logstash_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. You can even
+use the included redis log device to send the logs directly to a redis broker
+instead.
+
+## Installation
+
+In your Gemfile:
+
+    gem 'md-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
+
+## 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`
+
+## Copyright
+
+Copyright (c) 2014 Shadab Ahmed, 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/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/device/redis.rb

@@ -0,0 +1,64 @@
+require 'redis'
+
+module LogStasher
+  module Device
+    class Redis
+
+      attr_reader :options, :redis
+
+      def initialize(options = {})
+        @options = default_options.merge(options)
+        validate_options
+        configure_redis
+      end
+
+      def data_type
+        options[:data_type]
+      end
+
+      def key
+        options[:key]
+      end
+
+      def redis_options
+        unless @redis_options
+          default_keys = default_options.keys
+          @redis_options = options.select { |k, v| !default_keys.include?(k) }
+        end
+
+        @redis_options
+      end
+
+      def write(log)
+        case data_type
+        when 'list'
+          redis.rpush(key, log)
+        when 'channel'
+          redis.publish(key, log)
+        else
+          fail "Unknown data type #{data_type}"
+        end
+      end
+
+      def close
+        redis.quit
+      end
+
+      private
+
+      def configure_redis
+        @redis = ::Redis.new(redis_options)
+      end
+
+      def default_options
+        { key: 'logstash', data_type: 'list' }
+      end
+
+      def validate_options
+        unless ['list', 'channel'].include?(options[:data_type])
+          fail 'Expected :data_type to be either "list" or "channel"'
+        end
+      end
+    end
+  end
+end

data/lib/logstasher/device/syslog.rb

@@ -0,0 +1,101 @@
+# inspired by [lumberjack](https://github.com/bdurand/lumberjack_syslog_device)
+
+require 'syslog'
+require 'thread'
+
+module LogStasher
+  module Device
+    class Syslog
+
+      SEMAPHORE = Mutex.new
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = parse_options(default_options.merge(options))
+        @closed  = false
+      end
+
+      def close
+        SEMAPHORE.synchronize do
+          ::Syslog.close if ::Syslog.opened?
+        end
+
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      def facility
+        options[:facility]
+      end
+
+      def flags
+        options[:flags]
+      end
+
+      def identity
+        options[:identity]
+      end
+
+      def priority
+        options[:priority]
+      end
+
+      def write(log)
+        fail ::RuntimeError, 'Cannot write. The device has been closed.' if closed?
+
+        with_syslog_open do
+          ::Syslog.log(facility, log)
+        end
+      end
+
+      private
+
+      def default_options
+        {
+          :identity => 'logstasher',
+          :facility => ::Syslog::LOG_LOCAL0,
+          :priority => ::Syslog::LOG_INFO,
+          :flags    => ::Syslog::LOG_PID | ::Syslog::LOG_CONS
+        }
+      end
+
+      def parse_option(value)
+        case value
+        when ::String
+          ::Syslog.const_get(value.to_s)
+        when ::Array
+          value.reduce(0) { |all, current| all |= parse_option(current) }
+        else
+          value
+        end
+      end
+
+      def parse_options(options)
+        options[:facility] = parse_option(options[:facility])
+        options[:priority] = parse_option(options[:priority])
+        options[:flags]    = parse_option(options[:flags])
+        options
+      end
+
+      def syslog_configured?
+        ::Syslog.ident == identity && ::Syslog.options == flags && ::Syslog.facility == facility
+      end
+
+      def with_syslog_open
+        SEMAPHORE.synchronize do
+          if ::Syslog.opened?
+            ::Syslog.reopen(identity, flags, facility) unless syslog_configured?
+          else
+            ::Syslog.open(identity, flags, facility)
+          end
+
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/logstasher/log_subscriber.rb

@@ -0,0 +1,138 @@
+require 'action_controller/log_subscriber'
+require 'active_support/log_subscriber'
+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::Subscriber
+
+    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],
+        :path       => extract_path(payload),
+        :route      => "#{payload[:controller]}##{payload[:action]}"
+      }
+    end
+
+    # Monkey patching to enable exception logging
+    def extract_exception(payload)
+      if payload[:exception]
+        exception, message = payload[:exception]
+        status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception)
+        message = "#{exception}\n#{message}\n#{($!.backtrace.join("\n"))}"
+        { :status => status, :error => message }
+      else
+        {}
+      end
+    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?
+        { :params => JSON.generate(payload[:params].except(*INTERNAL_PARAMS)) }
+      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/railtie.rb

@@ -0,0 +1,56 @@
+module LogStasher
+  class Railtie < ::Rails::Railtie
+    config.logstasher = ::ActiveSupport::OrderedOptions.new
+    config.logstasher.enabled = false
+    config.logstasher.include_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.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::Subscriber.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', "logstash_#{::Rails.env}.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.0.0.rc1"
+end

data/lib/logstasher.rb

@@ -0,0 +1,50 @@
+require 'logger'
+
+module LogStasher
+  class << self
+    attr_reader :append_fields_callback
+    attr_writer :enabled
+    attr_writer :include_parameters
+    attr_writer :silence_standard_logging
+
+    def append_fields(&block)
+      @append_fields_callback = block
+    end
+
+    def enabled?
+      @enabled ||= false
+    end
+
+    def include_parameters?
+      if @include_parameters.nil?
+        @include_parameters = true
+      end
+
+      @include_parameters
+    end
+
+    def initialize_logger(device = $stdout, level = ::Logger::INFO)
+      ::Logger.new(device).tap do |new_logger|
+        new_logger.level = level
+      end
+    end
+
+    def logger
+      @logger ||= initialize_logger
+    end
+
+    def logger=(log)
+      @logger = log
+    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/md-logstasher.rb

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

data/logstasher.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "logstasher/version"
+
+Gem::Specification.new do |s|
+  s.name        = "md-logstasher"
+  s.version     = LogStasher::VERSION
+  s.authors     = ["Devin Christensen"]
+  s.email       = ["devin.christensen@moneydesktop.com"]
+  s.homepage    = "https://github.com/moneydesktop/logstasher"
+  s.summary     = %q{Awesome rails logs}
+  s.description = %q{Awesome rails logs}
+  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"
+end

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

@@ -0,0 +1,79 @@
+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
+    device.options.should eq(default_options)
+  end
+
+  it 'creates a redis instance' do
+    ::Redis.should_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'))
+    device = LogStasher::Device::Redis.new(db: '0')
+    device.redis_options.should eq(db: '0')
+  end
+
+  it 'has a key' do
+    device = LogStasher::Device::Redis.new(key: 'the_key')
+    device.key.should eq 'the_key'
+  end
+
+  it 'has a data_type' do
+    device = LogStasher::Device::Redis.new(data_type: 'channel')
+    device.data_type.should 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
+    device.redis.should_receive(:quit)
+    device.close
+  end
+
+  it 'works as a logger device' do
+    device = LogStasher::Device::Redis.new
+    device.should_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')
+      device.redis.should_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')
+      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')
+      device.write('the log')
+    end
+  end
+
+end

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

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+require 'logstasher/device/syslog'
+
+describe LogStasher::Device::Syslog do
+
+  let(:default_options) {{
+    :identity => 'logstasher',
+    :facility => ::Syslog::LOG_LOCAL0,
+    :priority => ::Syslog::LOG_INFO,
+    :flags    => ::Syslog::LOG_PID | ::Syslog::LOG_CONS
+  }}
+
+  before { ::Syslog.stub(:log) }
+
+  around do |example|
+    ::Syslog.close if ::Syslog.opened?
+    example.run
+    ::Syslog.close if ::Syslog.opened?
+  end
+
+  it 'has default options' do
+    device = LogStasher::Device::Syslog.new
+    device.options.should eq(default_options)
+  end
+
+  it 'has an identity' do
+    device = LogStasher::Device::Syslog.new(:identity => 'rspec')
+    device.identity.should eq 'rspec'
+  end
+
+  it 'has a facility' do
+    device = LogStasher::Device::Syslog.new(:facility => ::Syslog::LOG_USER)
+    device.facility.should eq ::Syslog::LOG_USER
+  end
+
+  it 'accepts facility as a string' do
+    device = LogStasher::Device::Syslog.new(:facility => 'LOG_LOCAL7')
+    device.facility.should eq ::Syslog::LOG_LOCAL7
+  end
+
+  it 'has a priority' do
+    device = LogStasher::Device::Syslog.new(:priority => ::Syslog::LOG_CRIT)
+    device.priority.should eq ::Syslog::LOG_CRIT
+  end
+
+  it 'accepts priority as a string' do
+    device = LogStasher::Device::Syslog.new(:priority => 'LOG_AUTH')
+    device.priority.should eq ::Syslog::LOG_AUTH
+  end
+
+  it 'has flags' do
+    device = LogStasher::Device::Syslog.new(:flags => ::Syslog::LOG_NOWAIT)
+    device.flags.should eq ::Syslog::LOG_NOWAIT
+  end
+
+  it 'accepts flags as a string' do
+    device = LogStasher::Device::Syslog.new(:flags => 'LOG_NDELAY')
+    device.flags.should eq ::Syslog::LOG_NDELAY
+  end
+
+  it 'accepts flags as an array of strings' do
+    device = LogStasher::Device::Syslog.new(:flags => ['LOG_NOWAIT', 'LOG_ODELAY'])
+    device.flags.should eq(::Syslog::LOG_NOWAIT | ::Syslog::LOG_ODELAY)
+  end
+
+  describe '#write' do
+    subject { LogStasher::Device::Syslog.new }
+
+    it 'opens syslog when syslog is closed' do
+      ::Syslog.should_receive(:open).with(subject.identity, subject.flags, subject.facility)
+      subject.write('a log')
+    end
+
+    it 'does not re-open syslog when its config is in sync' do
+      ::Syslog.open(subject.identity, subject.flags, subject.facility)
+      ::Syslog.should_not_receive(:open)
+      ::Syslog.should_not_receive(:reopen)
+      subject.write('a log')
+    end
+
+    it 're-opens syslog when its config is out of sync' do
+      ::Syslog.open('temp', ::Syslog::LOG_NDELAY, ::Syslog::LOG_AUTH)
+      ::Syslog.should_receive(:reopen).with(subject.identity, subject.flags, subject.facility)
+      subject.write('a log')
+    end
+
+    it 'writes the log to syslog' do
+      ::Syslog.should_receive(:log).with(subject.facility, 'a log')
+      subject.write('a log')
+    end
+
+    it 'fails when the device is closed' do
+      subject.close
+      expect {
+        subject.write('a log')
+      }.to raise_error(::RuntimeError, 'Cannot write. The device has been closed.')
+    end
+  end
+
+  describe '#close' do
+    subject { LogStasher::Device::Syslog.new }
+
+    it 'closes the device' do
+      subject.close
+      subject.should be_closed
+    end
+
+    it 'closes syslog when syslog is open' do
+      ::Syslog.open(subject.identity, subject.flags, subject.facility)
+      ::Syslog.should_receive(:close)
+      subject.close
+    end
+
+    it 'does not close syslog if it is already closed' do
+      ::Syslog.should_not_receive(:close)
+      subject.close
+    end
+  end
+end

data/spec/lib/logstasher/log_subscriber_spec.rb

@@ -0,0 +1,155 @@
+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
+      logger.should_receive(:<<) do |json|
+        JSON.parse(json).should 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],
+          '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
+
+      logger.should_receive(:<<) do |json|
+        fields = JSON.parse(json)
+        fields['user_id'].should eq mock_controller.user_id
+        fields['other'].should eq 'stuff'
+      end
+
+      subject.process_action(event)
+    end
+
+    it 'removes parameters from the log' do
+      ::LogStasher.stub(:include_parameters? => false)
+
+      logger.should_receive(:<<) do |json|
+        JSON.parse(json)['params'].should be_nil
+      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)
+
+      logger.should_receive(:<<) do |json|
+        JSON.parse(json)['location'].should 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
+      })
+
+      logger.should_receive(:<<) do |json|
+        runtime = JSON.parse(json)['runtime']
+        runtime['view'].should eq 3.3
+        runtime['db'].should 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']
+        })
+
+        logger.should_receive(:<<) do |json|
+          log = JSON.parse(json)
+          log['error'].should match /^RuntimeError\nit no work\n.+/m
+          log['status'].should eq 500
+          log['tags'].should 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)
+      Thread.current[:logstasher_context][:location].should eq location
+    end
+  end
+end

data/spec/lib/logstasher/railtie_spec.rb

@@ -0,0 +1,127 @@
+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.silence_standard_logging = "silence_standard_logging"
+
+      ::LogStasher.should_receive(:enabled=).with("enabled")
+      ::LogStasher.should_receive(:include_parameters=).with("include_parameters")
+      ::LogStasher.should_receive(:silence_standard_logging=).with("silence_standard_logging")
+      ::LogStasher.should_receive(:logger=).with(config.logger).and_call_original
+      config.logger.should_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
+        ::ActiveSupport.should_not_receive(:on_load)
+
+        subject.run
+      end
+    end
+
+    context 'when logstasher is enabled' do
+      before { ::LogStasher.stub(:enabled?) { true } }
+
+      it 'should load LogStasher into ActionController' do
+        ::ActionController.should_receive(:require).with('logstasher/log_subscriber')
+        ::ActionController.should_receive(:require).with('logstasher/context_wrapper')
+        ::ActionController.should_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 { ::LogStasher.stub(:enabled?) { true } }
+
+      context 'and silence_standard_logging is enabled' do
+        before { ::LogStasher.stub(:silence_standard_logging?) { true } }
+
+        it 'should not silence standard logging' do
+          ::ActionController::LogSubscriber.should_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActionView::LogSubscriber.should_receive(:include).with(::LogStasher::SilentLogger)
+          ::Rails::Rack::Logger.should_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+
+      context 'and silence_standard_logging is disabled' do
+        before { ::LogStasher.stub(:silence_standard_logging?) { false } }
+
+        it 'should not silence standard logging' do
+          ::ActionController.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActionView.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::Rails::Rack::Logger.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+    end
+
+    context 'when logstasher is disabled' do
+      before { ::LogStasher.stub(:enabled?) { false } }
+
+      context 'and silence_standard_logging is enabled' do
+        before { ::LogStasher.stub(:silence_standard_logging?) { true } }
+
+        it 'should not silence standard logging' do
+          ::ActionController::LogSubscriber.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActionView::LogSubscriber.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::Rails::Rack::Logger.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActiveSupport.run_load_hooks(:after_initialize, ::LogStasher::RailtieApp)
+        end
+      end
+
+      context 'and silence_standard_logging is disabled' do
+        before { ::LogStasher.stub(:silence_standard_logging?) { false } }
+
+        it 'should not silence standard logging' do
+          ::ActionController.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::ActionView.should_not_receive(:include).with(::LogStasher::SilentLogger)
+          ::Rails::Rack::Logger.should_not_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
+    ::LogStasher::VERSION.should_not be_nil
+  end
+
+  it 'has a logger' do
+    ::LogStasher.logger.should 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)
+    ::LogStasher.append_fields_callback.should be callback
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# 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.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: md-logstasher
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Devin Christensen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-21 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
+description: Awesome rails logs
+email:
+- devin.christensen@moneydesktop.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/device/redis.rb
+- lib/logstasher/device/syslog.rb
+- lib/logstasher/log_subscriber.rb
+- lib/logstasher/railtie.rb
+- lib/logstasher/silent_logger.rb
+- lib/logstasher/version.rb
+- lib/md-logstasher.rb
+- log/logstash_development.log
+- log/logstash_test.log
+- log/test.log
+- logstasher.gemspec
+- spec/lib/logstasher/device/redis_spec.rb
+- spec/lib/logstasher/device/syslog_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/moneydesktop/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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Awesome rails logs
+test_files:
+- spec/lib/logstasher/device/redis_spec.rb
+- spec/lib/logstasher/device/syslog_spec.rb
+- spec/lib/logstasher/log_subscriber_spec.rb
+- spec/lib/logstasher/railtie_spec.rb
+- spec/lib/logstasher_spec.rb
+- spec/spec_helper.rb