stasher 0.1.0

data/lib/stasher/logger.rb

@@ -0,0 +1,40 @@
+require 'logger'
+
+module Stasher
+  class Logger < ::Logger
+    def initialize(device = nil)
+      super(device)
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      severity ||= UNKNOWN
+      if severity < @level
+        return true
+      end
+
+      progname ||= @progname
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+
+      if message.is_a? String
+        message = format_message(severity, Time.now, progname, message).chomp
+      end
+
+      severity = format_severity(severity)
+
+      Stasher.log severity, message
+
+      true
+    end    
+
+    private
+
+    
+  end
+end

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

@@ -0,0 +1,31 @@
+module ActionController
+  module Instrumentation
+    def process_action(*args)
+      raw_payload = {
+          :controller => self.class.name,
+          :action     => self.action_name,
+          :params     => request.filtered_parameters,
+          :ip         => request.remote_ip,
+          :format     => request.format.try(:ref),
+          :method     => request.method,
+          :path       => (request.fullpath rescue "unknown")
+      }
+
+      Stasher.add_default_fields_to_scope(Stasher::CurrentScope.fields, request)
+
+      if self.respond_to?(:stasher_add_custom_fields_to_scope)
+        stasher_add_custom_fields_to_scope(Stasher::CurrentScope.fields)
+      end
+
+      ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup)
+
+      ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload|
+        result = super
+        payload[:status] = response.status
+        append_info_to_payload(payload)
+        result
+      end
+    end
+
+  end
+end

data/lib/stasher/rails_ext/rack/logger.rb

@@ -0,0 +1,24 @@
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    # Overwrites defaults of Rails::Rack::Logger that cause
+    # unnecessary logging.
+    # This effectively removes the log lines from the log
+    # that say:
+    # Started GET / for 192.168.2.1...
+    class Logger
+      # Overwrites Rails 3.2 code that logs new requests
+      def call_app(*args)
+        env = args.last
+        @app.call(env)
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      # Overwrites Rails 3.0/3.1 code that logs new requests
+      def before_dispatch(env)
+      end
+    end
+  end
+end

data/lib/stasher/railtie.rb

@@ -0,0 +1,17 @@
+require 'rails/railtie'
+require 'action_view/log_subscriber'
+require 'action_controller/log_subscriber'
+
+module Stasher
+  class Railtie < Rails::Railtie
+    config.stasher = ActiveSupport::OrderedOptions.new
+    config.stasher.enabled = false
+    config.stasher.suppress_app_log = true
+    config.stasher.redirect_logger = false
+    config.stasher.attach_to = [ :action_controller, :active_record]
+
+    initializer 'stasher' do |app|
+      Stasher.setup(app) if app.config.stasher.enabled
+    end
+  end
+end

data/lib/stasher/version.rb

@@ -0,0 +1,3 @@
+module Stasher
+  VERSION = "0.1.0"
+end

data/spec/factories/payloads.rb

@@ -0,0 +1,25 @@
+FactoryGirl.define do
+  factory :actioncontroller_payload, class: Hash do
+    skip_create
+
+    status 200
+    format 'application/json'
+    method 'GET'
+    path '/home?foo=bar'
+    ip "127.0.0.1"
+    params { {:controller => 'home', :action => 'index', 'foo' => 'bar' }.with_indifferent_access }
+    db_runtime 0.02
+    view_runtime 0.01
+    
+    initialize_with { attributes }
+  end
+
+  factory :activerecord_sql_payload, class: Hash do
+    skip_create
+
+    sql "SELECT * FROM `users` WHERE `users`.`id` = 5"
+    name 'User Load'
+    
+    initialize_with { attributes }
+  end
+end

data/spec/lib/stasher/current_scope_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Stasher::CurrentScope do
+  describe '.clear!' do
+    before :each do
+      Stasher::CurrentScope.fields[:foo] = 'bar'
+      Stasher::CurrentScope.fields[:baz] = { :bat => "man" }
+    end
+
+    it "removes all existing fields" do
+      Stasher::CurrentScope.clear!
+
+      Stasher::CurrentScope.fields.should == {}
+    end
+  end
+
+  describe ".fields" do 
+    before :each do
+      Stasher::CurrentScope.fields = { :foo => "bar" }
+    end
+
+    it "can retrive a value" do
+      Stasher::CurrentScope.fields[:foo].should == "bar"
+    end
+  end
+
+  describe ".fields=" do 
+    it "can assign all fields at once" do
+      Stasher::CurrentScope.fields = { :foo => "bar" }
+
+      Stasher::CurrentScope.fields[:foo].should == "bar"
+    end
+
+    it "overwrites exisitng fields" do
+      Stasher::CurrentScope.fields[:baz] = { :bat => "man" }
+
+      Stasher::CurrentScope.fields = { :foo => "bar" }
+
+      Stasher::CurrentScope.fields.should == { :foo => "bar" }
+    end
+  end
+end

data/spec/lib/stasher/log_subscriber_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+describe Stasher::LogSubscriber do
+  let(:logger) { MockLogger.new }
+  
+  before :each do
+    Stasher.logger = logger
+    Stasher.stub(:source).and_return("source")
+    LogStash::Time.stub(:now => 'timestamp')
+  end
+
+  subject(:subscriber) { Stasher::LogSubscriber.new }
+
+  describe '#start_processing' do
+    let(:payload) { FactoryGirl.create(:actioncontroller_payload) }
+
+    let(:event) {
+      ActiveSupport::Notifications::Event.new(
+        'process_action.action_controller', Time.now, Time.now, 2, payload
+      )
+    }
+
+    let(:json) { 
+      '{"@source":"source","@tags":["request"],"@fields":{"method":"GET","ip":"127.0.0.1","params":{"foo":"bar"},' +
+      '"path":"/home","format":"application/json","controller":"home","action":"index"},"@timestamp":"timestamp"}' + "\n" 
+    }
+
+    it 'calls all extractors and outputs the json' do
+      subscriber.should_receive(:extract_request).with(payload).and_return({:request => true})
+      subscriber.should_receive(:extract_current_scope).with(no_args).and_return({:custom => true})
+      subscriber.start_processing(event)
+    end
+
+    it "logs the event" do
+      subscriber.start_processing(event)
+
+      logger.messages.first.should == json
+    end
+  end
+
+  describe '#sql' do
+    let(:event) {
+      ActiveSupport::Notifications::Event.new(
+        'sql.active_record', Time.now, Time.now, 2, payload
+      )
+    }
+
+    context "for SCHEMA events" do
+      let(:payload) { FactoryGirl.create(:activerecord_sql_payload, name: 'SCHEMA') }
+
+      it "does not log anything" do
+        subscriber.sql(event)
+
+        logger.messages.should be_empty
+      end
+    end
+
+    context "for unnamed events" do
+      let(:payload) { FactoryGirl.create(:activerecord_sql_payload, name: '') }
+
+      it "does not log anything" do
+        subscriber.sql(event)
+
+        logger.messages.should be_empty
+      end
+    end
+
+    context "for session events" do
+      let(:payload) { FactoryGirl.create(:activerecord_sql_payload, name: 'ActiveRecord::SessionStore') }
+
+      it "does not log anything" do
+        subscriber.sql(event)
+
+        logger.messages.should be_empty
+      end
+    end
+
+    context "for any other events" do
+      let(:payload) { FactoryGirl.create(:activerecord_sql_payload) }
+
+      let(:json) { 
+        '{"@source":"source","@tags":["sql"],"@fields":{"name":"User Load","sql":"' + 
+        payload[:sql] + '","duration":0.0},"@timestamp":"timestamp"}' + "\n" 
+      }
+
+      it 'calls all extractors and outputs the json' do
+        subscriber.should_receive(:extract_sql).with(payload).and_return({:sql => true})
+        subscriber.should_receive(:extract_current_scope).with(no_args).and_return({:custom => true})
+        subscriber.sql(event)
+      end
+
+      it "logs the event" do
+        subscriber.sql(event)
+
+        logger.messages.first.should == json
+      end
+    end
+  end
+
+  describe '#process_action' do
+    let(:payload) { FactoryGirl.create(:actioncontroller_payload) }
+
+    let(:event) {
+      ActiveSupport::Notifications::Event.new(
+        'process_action.action_controller', Time.now, Time.now, 2, payload
+      )
+    }
+
+    let(:json) { 
+      '{"@source":"source","@tags":["response"],"@fields":{"method":"GET","ip":"127.0.0.1","params":{"foo":"bar"},' +
+      '"path":"/home","format":"application/json","controller":"home","action":"index","status":200,' + 
+      '"duration":0.0,"view":0.01,"db":0.02},"@timestamp":"timestamp"}' + "\n" 
+    }
+
+    it 'calls all extractors and outputs the json' do
+      subscriber.should_receive(:extract_request).with(payload).and_return({:request => true})
+      subscriber.should_receive(:extract_status).with(payload).and_return({:status => true})
+      subscriber.should_receive(:runtimes).with(event).and_return({:runtimes => true})
+      subscriber.should_receive(:extract_exception).with(payload).and_return({:exception => true})
+      subscriber.should_receive(:extract_current_scope).with(no_args).and_return({:custom => true})
+      subscriber.process_action(event)
+    end
+
+    it "logs the event" do
+      subscriber.process_action(event)
+
+      logger.messages.first.should == json
+    end
+
+    context "when the payload includes an exception" do
+      before :each do
+        payload[:exception] = [ 'Exception', 'message' ]
+        subscriber.stub(:extract_exception).and_return({})        
+      end
+
+      it "adds the 'exception' tag" do
+        subscriber.process_action(event)
+
+        logger.messages.first.should match %r|"@tags":\["response","exception"\]|
+      end
+    end
+
+    it "clears the scoped parameters" do
+      Stasher::CurrentScope.should_receive(:clear!)
+
+      subscriber.process_action(event)
+    end
+
+    context "with a redirect" do
+      before do
+        Stasher::CurrentScope.fields[:location] = "http://www.example.com"
+      end
+
+      it "adds the location to the log line" do
+        subscriber.process_action(event)
+        logger.messages.first.should match %r|"@fields":{.*?"location":"http://www\.example\.com".*?}|
+      end
+    end
+  end
+
+  describe '#log_event' do
+    it "sets the type as a @tag" do
+      subscriber.send :log_event, 'tag', {}
+
+      logger.messages.first.should match %r|"@tags":\["tag"\]|
+    end
+
+    it "renders the data in the @fields" do
+      subscriber.send :log_event, 'tag', { "foo" => "bar", :baz => 'bot' }
+
+      logger.messages.first.should match %r|"@fields":{"foo":"bar","baz":"bot"}|
+    end
+
+    it "sets the @source" do
+      subscriber.send :log_event, 'tag', {}
+
+      logger.messages.first.should match %r|"@source":"source"|
+    end
+
+    context "with a block" do
+      it "calls the block with the new event" do
+        yielded = []
+        subscriber.send :log_event, 'tag', {} do |args|
+          yielded << args
+        end
+
+        yielded.size.should == 1
+        yielded.first.should be_a(LogStash::Event)
+      end
+
+      it "logs the modified event" do
+        subscriber.send :log_event, 'tag', {} do |event|
+          event.tags << "extra"
+        end
+
+        logger.messages.first.should match %r|"@tags":\["tag","extra"\]|
+      end
+    end
+  end
+
+  describe '#redirect_to' do
+    let(:event) {
+      ActiveSupport::Notifications::Event.new(
+        'redirect_to.action_controller', Time.now, Time.now, 1, :location => 'http://example.com', :status => 302
+      )
+    }
+
+    it "stores the payload location in the current scope" do     
+      subscriber.redirect_to(event)
+
+      Stasher::CurrentScope.fields[:location].should == "http://example.com"
+    end
+  end
+end

data/spec/lib/stasher/logger_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Stasher::Logger do
+  subject (:logger) { Stasher::Logger.new }
+
+  before :each do
+    logger.level = ::Logger::WARN
+  end
+
+  it "logs messages that are at the configured level" do
+    Stasher.should_receive(:log).with('WARN', 'message')
+
+    logger.warn 'message'
+  end
+
+  it "logs messages that are above the configured level" do
+    Stasher.should_receive(:log).with('ERROR', 'message')
+
+    logger.error 'message'
+  end
+
+  it "does not log messages that are below the configured level" do
+    Stasher.should_not_receive(:log)
+
+    logger.info 'message'
+  end
+
+  it "formats the severity" do
+    Stasher.should_receive(:log).with('WARN', 'message')
+
+    logger.add ::Logger::WARN, "message"
+  end
+
+  it "returns true" do
+    Stasher.stub(:log)
+
+    logger.add( ::Logger::WARN, "message" ).should be_true
+  end
+
+  context "when there is a block given" do
+    it "yields to the block" do
+      Stasher.stub(:log)
+
+      expect { |b|
+        logger.add ::Logger::WARN, &b
+      }.to yield_with_no_args
+    end
+
+    it "logs the returned message" do
+      Stasher.should_receive(:log).with('WARN', 'message')
+
+      logger.add ::Logger::WARN do
+        "message"
+      end      
+    end
+  end
+
+  context "when the message is a string" do    
+    it "formats the message" do
+      logger.should_receive(:format_message).with(::Logger::WARN, an_instance_of(Time), nil, "message").and_return("formatted")
+      Stasher.stub(:log)
+
+      logger.warn 'message'
+    end
+
+    it "renders the formatted message" do
+      logger.stub(:format_message).and_return("formatted")
+      Stasher.should_receive(:log).with('WARN', 'formatted')
+
+      logger.warn 'message'
+    end
+  end
+
+  context "when the message is an object" do
+    let (:message) { Object.new }
+
+    it "does not format the message" do
+      logger.should_not_receive(:format_message)
+      Stasher.stub(:log)
+
+      logger.warn message
+    end
+
+    it "logs the raw message object" do
+      Stasher.should_receive(:log).with('WARN', message)
+
+      logger.warn message
+    end
+  end
+end