rails-logstasher 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDk3MDhmNmExY2Y2NDM5MmFiY2Y1OTRhZjBmNzU3YzU5NGRjMmM2Ng==
+  data.tar.gz: !binary |-
+    ZjI1YTkzZWQzZDQ3MzRmYWFmNzZlMGE0ZmIwOWJiMzkwYmE0Y2EyYw==
+SHA512:
+  metadata.gz: !binary |-
+    OGMwMDBlNjMyOWM2MTEyYTY3NjYxOTAzMmVmNzAxZWM4MzQwNGZkYzVhMjZj
+    MTk0MjhjYzNiNDM4M2FjY2ZlOTM4ZjQ3MzU3N2VmZTIwMzBiMzc2MGVmN2Qw
+    YTY1MzlmYTA5ZjQyNTdmOGNjYzkyYmVkMDQ3YzA5MGQzNDE4MzI=
+  data.tar.gz: !binary |-
+    ZDQyZmUyZmJkMjFmOTRjMWVhNTljYmZhOGVlM2UzOTQyMzQyMGQ4NzNiNWJm
+    YTdmYjI1NmJiNmE0ZDA2MDg4ZmZkNmQ3NjFkZTMyNDNiMTQ2MWY4ZmI2ODQz
+    M2RkYjQ0MjBlMmY2MTU4OTdjOTY0NjcyN2MxODQyNzNhM2RhY2Q=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Jeffrey Jones
+
+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,100 @@
+# RailsLogstasher
+
+[![Build Status](https://secure.travis-ci.org/capriza/rails-logstasher.png)](http://travis-ci.org/capriza/rails-logstasher)
+[![Coverage Status](https://coveralls.io/repos/capriza/rails-logstasher/badge.png?branch=master)](https://coveralls.io/r/capriza/rails-logstasher)
+[![Code Climate](https://codeclimate.com/github/capriza/rails-logstasher.png)](https://codeclimate.com/github/capriza/rails-logstasher)
+[![Dependency Status](https://gemnasium.com/capriza/rails-logstasher.png)](https://gemnasium.com/capriza/rails-logstasher)
+
+Logstash logging system for Ruby on Rails.
+This is a fork from https://github.com/rurounijones/yarder.
+
+This gem will create JSON based log entries designed for consumption by Logstash version 1.2.
+The JSON will contain the same information as can be found in the default rails logging output.
+
+## Current Status
+
+All logging in a Rails3 app should be JSON formatted, including ad-hoc logging.
+
+RailsLogstasher has been tested against Rails 3.2.16 on Ruby 1.9.3.
+
+## Installation
+
+Add this line to your Rails application's Gemfile:
+
+```ruby
+gem 'rails-logstasher'
+```
+
+## Configuration
+
+RailsLogstasher uses the Rails logger (set using config.logger in application.rb)to log output.
+
+By default Rails uses the TaggedLogging class to provide this however because RailsLogstasher
+replaces it you will need to change the default to something else.
+
+You will need to specify a Ruby Logger compatible logger. RailsLogstasher provides its own
+logger which is a copy of the ActiveSupport::Logger (Formerly known as
+ActiveSupport::BufferedLogger)
+
+If you are not sure what you want yet then set the RailsLogstasher::Logger as in the example
+below in your application.rb file.
+
+```ruby
+module MyApp
+  class Application < Rails::Application
+
+    # Set a logger compatible with the standard ruby logger to be used by RailsLogstasher
+    config.logger = RailsLogstasher::Logger.new(Rails.root.join('log',"#{Rails.env}.log").to_s)
+
+  end
+end
+```
+
+## Logstash Configuration
+
+RailsLogstasher creates log entries with a default type of "rails", therefore your Logstash
+configuration file should be as follows:
+
+```
+input {
+  file {
+    type => "rails"
+    path => "/var/www/rails/application-1/log/production.log" # Path to your log file
+    format => "json_event"
+  }
+}
+```
+
+The type can be configured via the application configuration "log_type" setting, like so:
+
+```
+module MyApp
+  class Application < Rails::Application
+
+    # Set a different type for the events
+    config.log_type = 'my_type'
+
+  end
+end
+```
+
+You will need to edit the path to point to your application's log file. Because RailsLogstasher creates json
+serialized Logstash::Event entries there is no need to setup any filters
+
+### Known issues
+
+RailsLogstasher currently creates nested JSON. Kibana has pretty good (With a few small UI problems) support
+for nested JSON but logstash web does not.
+
+## Developers
+
+Thoughts, suggestions, opinions and contributions are welcome. 
+
+When contributing please make sure to run your tests with warnings enabled and make sure that
+rails-logstasher creates no warnings. (Warnings from other libraries like capybara etc. are ok)
+
+```
+RUBYOPT=-w rake
+```
+
+

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsLogstasher'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/rails_logstasher.rb

@@ -0,0 +1,16 @@
+require 'rails_logstasher/railtie' if defined?(Rails)
+require 'rails_logstasher/rack/logger'
+require 'rails_logstasher/event'
+require 'logstash-event'
+require 'rails_logstasher/logger'
+require 'rails_logstasher/tagged_logging'
+
+module RailsLogstasher
+
+  class IncompatibleLogger < StandardError; end
+
+  def self.log_entries
+    @@events ||= {}
+  end
+
+end

data/lib/rails_logstasher/action_controller/log_subscriber.rb

@@ -0,0 +1,75 @@
+require 'rails_logstasher/core_ext/object/blank'
+
+module RailsLogstasher
+  module ActionController
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+      INTERNAL_PARAMS = %w(controller action format _method only_path)
+
+      def start_processing(event)
+        payload = event.payload
+
+        entry.fields['controller'] = payload[:controller]
+        entry.fields['action'] = payload[:action]
+
+        format  = payload[:format]
+        entry.fields['format']  = format.to_s.downcase if format.is_a?(Symbol)
+
+      end
+
+      def process_action(event)
+
+        payload   = event.payload
+        #TODO Think about additions. Comment out for the moment to shut up warnings
+        #additions = ::ActionController::Base.log_process_action(payload)
+
+        params = payload[:params].except(*INTERNAL_PARAMS)
+        entry.fields['parameters'] = params unless params.empty?
+
+        entry.fields['controller_duration'] = event.duration
+
+        #TODO  What on earth are additions and how should we handle them?
+        # message << " (#{additions.join(" | ")})" unless additions.blank?
+
+      end
+
+      def halted_callback(event)
+        entry.fields['halted_callback'] = event.payload[:filter]
+      end
+
+      def send_file(event)
+        entry.fields['send_file'] = event.payload[:path]
+        entry.fields['send_file_duration'] = event.duration
+      end
+
+      def redirect_to(event)
+        entry.fields['redirect_to'] = event.payload[:location]
+      end
+
+      def send_data(event)
+        entry.fields['send_data'] = event.payload[:filename]
+        entry.fields['send_data_duration'] = event.duration
+      end
+
+      %w(write_fragment read_fragment exist_fragment?
+         expire_fragment expire_page write_page).each do |method|
+        class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{method}(event)
+            entry.fields['cache'] ||= []
+            cache_event = {}
+            cache_event['key_or_path'] = event.payload[:key] || event.payload[:path]
+            cache_event['type'] = #{method.to_s.humanize.inspect}
+            cache_event['duration'] = event.duration
+            entry.fields['cache'] << cache_event
+          end
+        METHOD
+      end
+
+    private
+
+      def entry
+        RailsLogstasher.log_entries[Thread.current]
+      end
+
+    end
+  end
+end

data/lib/rails_logstasher/action_view/log_subscriber.rb

@@ -0,0 +1,31 @@
+module RailsLogstasher
+  module ActionView
+
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+
+      def render_template(event)
+        entry.fields['rendering'] ||= []
+        render_entry = {}
+        render_entry['identifier'] = from_rails_root(event.payload[:identifier])
+        render_entry['layout'] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
+        render_entry['duration'] = event.duration
+
+        entry.fields['rendering'] << render_entry
+
+      end
+      alias :render_partial :render_template
+      alias :render_collection :render_template
+
+    private
+
+      def from_rails_root(string)
+        string.sub("#{Rails.root}/", "").sub(/^app\/views\//, "")
+      end
+
+      def entry
+        RailsLogstasher.log_entries[Thread.current]
+      end
+
+    end
+  end
+end

data/lib/rails_logstasher/active_record/log_subscriber.rb

@@ -0,0 +1,88 @@
+require "securerandom"
+
+module RailsLogstasher
+  module ActiveRecord
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+
+      def self.runtime=(value)
+        Thread.current["active_record_sql_runtime"] = value
+      end
+
+      def self.runtime
+        Thread.current["active_record_sql_runtime"] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      def initialize
+        super
+      end
+
+      def sql(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        payload = event.payload
+
+        return if 'SCHEMA' == payload[:name]
+
+        sql_entry = {}
+        sql_entry['name'] = payload[:name]
+        sql_entry['duration'] = event.duration
+        sql_entry['sql']= payload[:sql].squeeze(' ')
+
+        binds = nil
+
+        unless (payload[:binds] || []).empty?
+          binds = "  " + payload[:binds].map { |col,v|
+            [col.name, v]
+          }.inspect
+        end
+
+        sql_entry['binds'] = binds unless binds.nil?
+
+        write_entry sql_entry
+      end
+
+      def identity(event)
+        return unless logger.debug?
+
+        payload = event.payload
+
+        sql_entry = {}
+        sql_entry['name'] = payload[:name]
+        sql_entry['line'] = payload[:line]
+        sql_entry['duration'] = payload[:duration]
+
+        write_entry sql_entry
+      end
+
+    private
+
+      def write_entry(sql_entry)
+        entry = log_entry
+        entry.fields['sql'] ||= []
+        entry.fields['sql'] << sql_entry
+        entry.write(false)
+      end
+
+      def logger
+        ::ActiveRecord::Base.logger
+      end
+
+      def log_entry
+        RailsLogstasher.log_entries[Thread.current] ||
+          RailsLogstasher::Event.new(Rails.logger, false).tap do |entry|
+          entry.fields['uuid'] = SecureRandom.uuid
+          #TODO Should really move this into the base logger
+          entry.source = Socket.gethostname
+          entry.type = "rails_json_log"
+        end
+      end
+
+    end
+  end
+end

data/lib/rails_logstasher/active_resource/log_subscriber.rb

@@ -0,0 +1,34 @@
+module RailsLogstasher
+  module ActiveResource
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+
+      def request(event)
+
+        #TODO Think of a better name for this!
+        entry.fields['active_resource'] ||= []
+
+        request_entry = {}
+
+        request_entry['method'] = event.payload[:method].to_s.upcase
+        request_entry['uri'] = event.payload[:request_uri]
+
+        result = event.payload[:result]
+
+        request_entry['code'] = result.code
+        request_entry['message'] = result.message
+        request_entry['length'] = result.body.to_s.length
+        request_entry['duration'] = event.duration
+
+        entry.fields['active_resource'] << request_entry
+      end
+
+    private
+
+      def entry
+        RailsLogstasher.log_entries[Thread.current]
+      end
+
+    end
+  end
+end
+

data/lib/rails_logstasher/core_ext/object/blank.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+# This file is copied verbatim from ActiveSupport for compatibility
+# should rails_logstasher be used outside of a Rails project. Therefor we
+# won't process this file if ActiveSupport is already defined
+unless defined?(ActiveSupport)
+  class Object
+    # An object is blank if it's false, empty, or a whitespace string.
+    # For example, '', ' ', +nil+, [], and {} are all blank.
+    #
+    # This simplifies:
+    #
+    # if address.nil? || address.empty?
+    #
+    # ...to:
+    #
+    # if address.blank?
+    def blank?
+      respond_to?(:empty?) ? empty? : !self
+    end
+
+    # An object is present if it's not <tt>blank?</tt>.
+    def present?
+      !blank?
+    end
+
+    # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+    # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+    #
+    # This is handy for any representation of objects where blank is the same
+    # as not present at all. For example, this simplifies a common check for
+    # HTTP POST/query parameters:
+    #
+    # state = params[:state] if params[:state].present?
+    # country = params[:country] if params[:country].present?
+    # region = state || country || 'US'
+    #
+    # ...becomes:
+    #
+    # region = params[:state].presence || params[:country].presence || 'US'
+    def presence
+      self if present?
+    end
+  end
+
+  class NilClass
+    # +nil+ is blank:
+    #
+    # nil.blank? # => true
+    def blank?
+      true
+    end
+  end
+
+  class FalseClass
+    # +false+ is blank:
+    #
+    # false.blank? # => true
+    def blank?
+      true
+    end
+  end
+
+  class TrueClass
+    # +true+ is not blank:
+    #
+    # true.blank? # => false
+    def blank?
+      false
+    end
+  end
+
+  class Array
+    # An array is blank if it's empty:
+    #
+    # [].blank? # => true
+    # [1,2,3].blank? # => false
+    alias_method :blank?, :empty?
+  end
+
+  class Hash
+    # A hash is blank if it's empty:
+    #
+    # {}.blank? # => true
+    # { key: 'value' }.blank? # => false
+    alias_method :blank?, :empty?
+  end
+
+  class String
+    # A string is blank if it's empty or contains whitespaces only:
+    #
+    # ''.blank? # => true
+    # ' '.blank? # => true
+    # '　'.blank? # => true
+    # ' something here '.blank? # => false
+    def blank?
+      self !~ /[^[:space:]]/
+    end
+  end
+
+  class Numeric #:nodoc:
+    # No number is blank:
+    #
+    # 1.blank? # => false
+    # 0.blank? # => false
+    def blank?
+      false
+    end
+  end
+end