rackstash 0.0.1 → 0.1.0

data/lib/rackstash/framework/base.rb

@@ -0,0 +1,13 @@
+module Rackstash
+  module Framework
+    module Base
+      def setup(config={})
+        Rackstash.request_fields = config.rackstash[:request_fields]
+        Rackstash.fields = config.rackstash[:fields] || HashWithIndifferentAccess.new
+        Rackstash.source = config.rackstash[:source]
+        Rackstash.log_level = config.rackstash[:log_level] || :info
+        Rackstash.tags = config.rackstash[:tags] || []
+      end
+    end
+  end
+end

data/lib/rackstash/framework/rack.rb

@@ -0,0 +1,9 @@
+module Rackstash
+  module Framework
+    module Rack
+      def setup(config={})
+        super
+      end
+    end
+  end
+end

data/lib/rackstash/framework/rails2.rb

@@ -0,0 +1,43 @@
+require 'rackstash/rails_ext/initializer'
+require 'initializer'
+Rails::Initializer.class_eval{ include Rackstash::RailsExt::Initializer }
+
+module Rackstash
+  module Framework
+    module Rails2
+      # This method MUST be called after Rails::Initializer#initialize_logger
+      # but before Rails::Initializer#initialize_framework_logging
+      # The Rackstash::RailsExt::Initializer module takes care of that.
+      def setup(config={})
+        super
+
+        unless Rails.logger.is_a?(Rackstash::BufferedLogger)
+          rackstash_logger = Rackstash::BufferedLogger.new(Rails.logger)
+          silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", rackstash_logger }
+          Rackstash.logger = rackstash_logger
+        end
+
+        if Rails.configuration.frameworks.include?(:action_controller)
+          require 'rackstash/rails_ext/action_controller'
+          ActionController::Base.class_eval{ include Rackstash::RailsExt::ActionController }
+
+          # Include the logger middleware at the earliest possible moment
+          # to add a log scope which captures all log lines of the request
+          ActionController::Dispatcher.middleware.insert(0, Rackstash::LogMiddleware)
+        end
+
+        if Rails.configuration.frameworks.include?(:active_record)
+          # The ANSI color codes in the ActiveRecord logs don't help much in
+          # plain JSON
+          ActiveRecord::Base.colorize_logging = false
+        end
+      end
+    end
+  end
+end
+
+Rails::Configuration.class_eval do
+  def rackstash
+    @rackstash ||= Rails::OrderedOptions.new
+  end
+end

data/lib/rackstash/framework/rails3.rb

@@ -0,0 +1,46 @@
+require 'rackstash/log_subscriber'
+
+module Rackstash
+  module Framework
+    module Rails3
+      def setup(config={})
+        super
+
+        unless Rails.logger.is_a?(Rackstash::BufferedLogger)
+          # This is required by ActiveRecord >= 4
+          if defined?(ActiveRecord::SessionStore::Extension::LoggerSilencer)
+            Rackstash::BufferedLogger.send(:include, ActiveRecord::SessionStore::Extension::LoggerSilencer)
+          end
+
+          Rackstash.logger = Rackstash::BufferedLogger.new(Rails.logger)
+          Rails.logger = Rackstash.logger
+          silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", Rackstash.logger }
+
+          ActiveRecord::Base.logger = Rackstash.logger if defined?(ActiveRecord::Base)
+          ActionController::Base.logger = Rackstash.logger if defined?(ActionController::Base)
+          # New in Rails 4
+          ActionView::Base.logger = Rackstash.logger if defined?(ActionView::Base) && ActionView::Base.respond_to?(:logger=)
+        end
+        # The ANSI color codes in the ActiveRecord logs don't help much in
+        # plain JSON
+        config.colorize_logging = false
+
+        log_subscriber = Rackstash::LogSubscriber.new
+        Rackstash::LogSubscriber.attach_to :action_controller, log_subscriber
+
+        # ActionDispatch captures exceptions too early for us to catch
+        # Thus, we inject our own exceptions_app to be able to catch the
+        # actual backtrace and add it to the fields
+        exceptions_app = config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
+        config.exceptions_app = lambda do |env|
+          log_subscriber._extract_exception_backtrace(env)
+          exceptions_app.call(env)
+        end
+
+        ActionController::Base.send :include, Rackstash::Instrumentation
+      end
+    end
+  end
+end
+
+require 'rackstash/railtie'

data/lib/rackstash/log_middleware.rb

@@ -0,0 +1,27 @@
+require 'rackstash'
+
+module Rackstash
+  class LogMiddleware
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Rackstash.with_log_buffer do
+        request = Rack::Request.new(env)
+        fields = {
+          :method => request.request_method,
+          :scheme => request.scheme,
+          :path => (request.fullpath rescue "unknown")
+        }
+        begin
+          status, headers, result = @app.call(env)
+        ensure
+          fields[:status] = status
+          Rackstash.logger.fields.reverse_merge!(fields) if Rackstash.logger.fields
+        end
+      end
+    end
+  end
+end

data/lib/rackstash/log_severity.rb

@@ -0,0 +1,9 @@
+module Rackstash
+  module LogSeverity
+    Severities = [:DEBUG, :INFO, :WARN, :ERROR, :FATAL, :UNKNOWN]
+
+    Severities.each_with_index do |s,i|
+      const_set(s, i)
+    end
+  end
+end

data/lib/rackstash/log_subscriber.rb

@@ -0,0 +1,108 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/log_subscriber'
+
+module Rackstash
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def process_action(event)
+      return unless Rails.logger.respond_to?(:fields) && Rails.logger.fields
+      payload = event.payload
+
+      data      = extract_request(payload)
+      data.merge! extract_exception(payload)
+      data.merge! runtimes(event)
+      data.merge! location(event)
+
+      Rails.logger.fields.reverse_merge!(data)
+      Rails.logger.fields.merge! request_fields(payload)
+    end
+
+    def redirect_to(event)
+      Thread.current[:rackstash_location] = event.payload[:location]
+    end
+
+    def _extract_exception_backtrace(env)
+      return unless env['action_dispatch.exception']
+
+      exception_wrapper = ActionDispatch::ExceptionWrapper.new(env, env['action_dispatch.exception'])
+      data = {
+        :error_backtrace => exception_wrapper.full_trace.join("\n")
+      }
+      Rails.logger.fields.reverse_merge!(data)
+    end
+
+
+    protected
+    def extract_request(payload)
+      {
+        :controller => payload[:params]['controller'],
+        :action => payload[:params]['action'],
+        :format => extract_format(payload)
+      }
+    end
+
+    def extract_format(payload)
+      if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0
+        payload[:formats].first
+      else
+        payload[:format]
+      end
+    end
+
+    def extract_exception(payload)
+      if payload[:exception]
+        exception, message = payload[:exception]
+        {
+          :error => exception.to_s,
+          :error_message => message
+        }
+      else
+        {}
+      end
+    end
+
+    def runtimes(event)
+      {
+        :duration => event.duration,
+        :view => event.payload[:view_runtime],
+        :db => event.payload[:db_runtime]
+      }.inject({}) do |runtimes, (name, runtime)|
+        runtimes[name] = round(runtime, 2) if runtime
+        runtimes
+      end
+    end
+
+    if 0.0.method(:round).arity == 0
+      def round(float, ndigits=0)
+        power = (10**ndigits).to_f
+        (float * power).round / power
+      end
+    else
+      def round(float, ndigits=0)
+        float.to_f.round(ndigits)
+      end
+    end
+
+
+    def location(event)
+      if location = Thread.current[:rackstash_location]
+        Thread.current[:rackstash_location] = nil
+        { :location => location }
+      else
+        {}
+      end
+    end
+
+    def request_fields(payload)
+      payload[:rackstash_request_fields] || {}
+    end
+  end
+
+  module Instrumentation
+    extend ActiveSupport::Concern
+
+    def append_info_to_payload(payload)
+      super
+      payload[:rackstash_request_fields] = Rackstash.request_fields(self)
+    end
+  end
+end

data/lib/rackstash/rails_ext/action_controller.rb

@@ -0,0 +1,101 @@
+# THIS IS FOR RAILS 2.x COMPATIBILITY ONLY
+#
+# This module, when included into ActionController::Base
+# makes sure that no superfluous log entries are generated during request
+# handling. Instead, only the configured Lograge output is generated
+
+module Rackstash
+  module RailsExt
+    module ActionController
+      def self.included(base)
+        base.class_eval do
+          # In Rails 2, the ActionController::Benchmark module we are actually
+          # patching is included before the ActionController::Rescue module.
+          # As we need to preserve the alias chain, we completely replace the call
+          # chain. An unmodified ActionController thus uses the following call
+          # chain for perform_action:
+          #
+          # perform_action_with_flash
+          # perform_action_without_flash     == perform_action_with_rescue
+          # perform_action_without_rescue    == perform_action_with_benchmark
+          # perform_action_without_benchmark == perform_action_with_filters
+          # perform_action_with_filters      == AC::Base#perform_action
+          #
+          # We replace the perform_action_without_rescue method with our own
+          # to keep up the call chain.
+
+          alias_method :perform_action_without_rescue, :perform_action_with_rackstash
+        end
+      end
+
+      private
+      def perform_action_with_rackstash
+        if logger
+          rackstash_fields = {
+            :controller => params["controller"],
+            :action => params["action"],
+            :format => params["format"]
+          }
+
+          ms = [Benchmark.ms { perform_action_without_benchmark }, 0.01].max
+          logging_view          = defined?(@view_runtime)
+          logging_active_record = Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
+
+          log_message  = 'Completed in %.0fms' % ms
+
+          if logging_view || logging_active_record
+            log_message << " ("
+            if logging_view
+              log_message << view_runtime
+              rackstash_fields[:view] = (@view_runtime * 100).round / 100.0
+            end
+
+            if logging_active_record
+              db_runtime = active_record_runtime_for_rackstash
+
+              log_message << ", " if logging_view
+              log_message << ("DB: %.0f" % db_runtime) + ")"
+              rackstash_fields[:db] = (db_runtime * 100).round / 100.0
+            else
+              ")"
+            end
+          end
+          log_message << " | #{response.status}"
+          log_message << " [#{complete_request_uri rescue "unknown"}]"
+
+          logger.info(log_message)
+          response.headers["X-Runtime"] = "%.0f" % ms
+
+          rackstash_fields[:duration] = (ms * 100).round / 100.0
+          rackstash_fields[:location] = response.location if response.location
+        else
+          perform_action_without_benchmark
+        end
+      rescue Exception => exception
+        rackstash_fields ||= {}
+        rackstash_fields[:error] = exception.class.name
+        rackstash_fields[:error_message] = exception.message
+        rackstash_fields[:error_backtrace] = exception.backtrace.join("\n") if exception.backtrace
+        raise
+      ensure
+        if logger && logger.respond_to?(:fields) && logger.fields
+          rackstash_fields ||= {}
+          logger.fields.reverse_merge!(rackstash_fields)
+
+          request_fields = Rackstash.request_fields(self)
+          logger.fields.merge!(request_fields) if request_fields
+        end
+      end
+
+      # Basically the same as ActionController::Benchmarking#active_record_runtime
+      # but we return a float instead of a pre-formatted string.
+      private
+      def active_record_runtime_for_rackstash
+        db_runtime = ActiveRecord::Base.connection.reset_runtime
+        db_runtime += @db_rt_before_render if @db_rt_before_render
+        db_runtime += @db_rt_after_render if @db_rt_after_render
+        db_runtime
+      end
+    end
+  end
+end

data/lib/rackstash/rails_ext/initializer.rb

@@ -0,0 +1,21 @@
+# THIS IS FOR RAILS 2.x COMPATIBILITY ONLY
+#
+# This module, when included into Rails::Initializer
+# makes sure that our buffered logger gets configured right away.
+
+module Rackstash
+  module RailsExt
+    module Initializer
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :initialize_logger, :rackstash
+        end
+      end
+
+      def initialize_logger_with_rackstash
+        initialize_logger_without_rackstash
+        Rackstash.setup(configuration) if configuration.rackstash.enabled
+      end
+    end
+  end
+end

data/lib/rackstash/railtie.rb

@@ -0,0 +1,19 @@
+require 'rails/railtie'
+require 'action_view/log_subscriber'
+require 'action_controller/log_subscriber'
+
+module Rackstash
+  class Railtie < Rails::Railtie
+    config.rackstash = ActiveSupport::OrderedOptions.new
+
+    config.rackstash.enabled = false
+
+    initializer :rackstash do |app|
+      if app.config.rackstash.enabled
+        Rackstash.setup(app.config)
+        app.middleware.insert(0, Rackstash::LogMiddleware)
+      end
+
+    end
+  end
+end

data/lib/rackstash/runner.rb

@@ -0,0 +1,36 @@
+require 'thor'
+require 'rackstash/buffered_logger'
+require 'stringio'
+
+module Rackstash
+  class Runner < Thor
+    default_task :capture
+
+    desc "capture", "Capture and buffer STDIN and generate a log entry on STDOUT"
+    method_option :tags, :type => :array, :required => false, :desc => "Tags to set on the Log entry"
+    method_option :fields, :type => :hash, :required => false, :desc => "Additional fields"
+    method_option :source, :type => :string, :required => false, :desc => "The source attribute"
+    def capture
+      logger.with_buffer do
+        $stdin.each_line do |line|
+          logger.info(line)
+        end
+        logger.source = options[:source]
+
+        logger.fields.merge!(options[:fields] || {})
+        logger.tags.push *(options[:tags] || [])
+      end
+
+      puts output.string
+    end
+
+  protected
+    def output
+      @output ||= StringIO.new
+    end
+
+    def logger
+      @logger ||= Rackstash::BufferedLogger.new(Logger.new(output))
+    end
+  end
+end