mongodb_logger 0.1.0

data/features/support/env.rb

@@ -0,0 +1,15 @@
+require 'active_support'
+require 'rspec'
+
+PROJECT_ROOT     = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
+TEMP_DIR         = File.join(PROJECT_ROOT, 'tmp').freeze
+LOCAL_RAILS_ROOT = File.join(TEMP_DIR, 'rails_root').freeze
+BUILT_GEM_ROOT   = File.join(TEMP_DIR, 'built_gems').freeze
+LOCAL_GEM_ROOT   = File.join(TEMP_DIR, 'local_gems').freeze
+
+Before do
+  FileUtils.mkdir_p(TEMP_DIR)
+  FileUtils.rm_rf(BUILT_GEM_ROOT)
+  FileUtils.rm_rf(LOCAL_RAILS_ROOT)
+  FileUtils.mkdir_p(BUILT_GEM_ROOT)
+end

data/features/support/rails.rb

@@ -0,0 +1,91 @@
+module RailsHelpers
+  def rails_root_exists?
+    File.exists?(environment_path)
+  end
+  
+  def environment_path
+    File.join(rails_root, 'config', 'environment.rb')
+  end
+
+  def application_controller_filename
+    controller_filename = File.join(rails_root, 'app', 'controllers', "application_controller.rb")
+  end
+
+  def rails_root
+    LOCAL_RAILS_ROOT
+  end
+  
+  def rails30?
+    rails_version =~ /^3.0/
+  end
+  
+  def rails31?
+    rails_version =~ /^3.1/
+  end
+
+  def rails_version
+    @rails_version ||= begin
+      rails_version = open(gemfile_path).read.match(/gem.*rails["'].*["'](.+)["']/)[1]
+    end
+  end
+
+  def gemfile_path
+    File.join(rails_root, 'Gemfile')
+  end
+
+  def rakefile_path
+    File.join(rails_root, 'Rakefile')
+  end
+  
+  def routes_path
+    File.join(rails_root, 'config', 'routes.rb')
+  end
+  
+  def logs_path
+    File.join(rails_root, 'log')
+  end
+
+  def bundle_gem(gem_name, version = nil)
+    File.open(gemfile_path, 'a') do |file|
+      gem = "gem '#{gem_name}'"
+      gem += ", '#{version}'" if version
+      file.puts(gem)
+    end
+  end
+  
+  def require_thread
+    content = File.read(rakefile_path)
+    content = "require 'thread'\n#{content}"
+    File.open(rakefile_path, 'wb') { |file| file.write(content) }
+  end
+  
+  def add_routes
+    content = File.read(routes_path)
+    flag = Regexp.escape("Application.routes.draw do\n")
+    content.gsub!(/#{flag}/m, '\0 resources :order')
+    File.open(routes_path, 'wb') { |file| file.write(content) }
+  end
+  
+  def copy_tests
+    FileUtils.cp(
+      File.join(PROJECT_ROOT, 'test', 'rails', 'app', 'controllers', 'order_controller.rb'), 
+      File.join(rails_root, 'app', 'controllers', 'order_controller.rb')
+    )
+    FileUtils.cp(
+      File.join(PROJECT_ROOT, 'test', 'config', 'samples', 'database.yml'), 
+      File.join(rails_root, 'config', 'database.yml')
+    )
+    FileUtils.cp(
+      File.join(PROJECT_ROOT, 'test', 'rails', 'test', 'test_helper.rb'), 
+      File.join(rails_root, 'test', 'test_helper.rb')
+    )
+    FileUtils.cp(
+      File.join(PROJECT_ROOT, 'test', 'rails', 'test', 'functional', 'order_controller_test.rb'), 
+      File.join(rails_root, 'test', 'functional', 'order_controller_test.rb')
+    )
+    FileUtils.chmod 0777, logs_path
+  end
+  
+end
+
+World(RailsHelpers)

data/features/support/terminal.rb

@@ -0,0 +1,94 @@
+require 'fileutils'
+
+Before do
+  @terminal = Terminal.new
+end
+
+After do |story|
+  if story.failed?
+    # puts @terminal.output
+  end
+end
+
+class Terminal
+  attr_reader :output, :status
+  attr_accessor :environment_variables
+
+  def initialize
+    @cwd = FileUtils.pwd
+    @output = ""
+    @status = 0
+    @logger = Logger.new(File.join(TEMP_DIR, 'terminal.log'))
+    
+    @environment_variables = {
+      "GEM_HOME" => LOCAL_GEM_ROOT,
+      "GEM_PATH" => "#{LOCAL_GEM_ROOT}:#{BUILT_GEM_ROOT}",
+      "PATH" => "#{gem_bin_path}:#{ENV['PATH']}"
+    }
+  end
+
+  def cd(directory)
+    @cwd = directory
+  end
+
+  def run(command)
+    output << "#{command}\n"
+    current_dir = FileUtils.pwd
+    
+    # The ; forces ruby to shell out so the env settings work right
+    cmdline = "sh -c 'cd #{@cwd} && #{environment_settings} #{command} 2>&1 ; '"
+    logger.debug(cmdline)
+    result = `#{cmdline}`
+    logger.debug(result)
+    output << result
+    
+    `sh -c 'cd #{current_dir}'`
+    @status = $?
+  end
+
+  def echo(string)
+    logger.debug(string)
+  end
+
+
+  def build_and_install_gem(gemspec)
+    pkg_dir = File.join(TEMP_DIR, 'pkg')
+    FileUtils.mkdir_p(pkg_dir)
+    output = `gem build #{gemspec} 2>&1`
+    gem_file = Dir.glob("*.gem").first
+    unless gem_file
+      raise "Gem didn't build:\n#{output}"
+    end
+    target = File.join(pkg_dir, gem_file)
+    FileUtils.mv(gem_file, target)
+    install_gem_to(LOCAL_GEM_ROOT, target)
+  end
+
+  def install_gem(gem)
+    install_gem_to(LOCAL_GEM_ROOT, gem)
+  end
+
+  def uninstall_gem(gem)
+    `gem uninstall -i #{LOCAL_GEM_ROOT} #{gem}`
+  end
+
+  def prepend_path(path)
+    @environment_variables['PATH'] = path + ":" + @environment_variables['PATH']
+  end
+
+  private
+
+  def install_gem_to(root, gem)
+    `gem install -i #{root} --no-ri --no-rdoc #{gem}`
+  end
+
+  def environment_settings
+    @environment_variables.map { |key, value| "#{key}=#{value}" }.join(' ')
+  end
+
+  def gem_bin_path
+    File.join(LOCAL_GEM_ROOT, "bin")
+  end
+
+  attr_reader :logger
+end

data/lib/mongodb_logger.rb

@@ -0,0 +1,31 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'mongo'
+require 'mongodb_logger/logger'
+require 'mongodb_logger/railtie' if defined?(Rails::Railtie)
+require 'mongodb_logger/version'
+
+module MongodbLogger
+  module Base
+    def self.included(base)
+      base.class_eval { around_filter :enable_mongodb_logger }
+    end
+
+    def enable_mongodb_logger
+      return yield unless Rails.logger.respond_to?(:mongoize)
+      f_params = case
+                   when request.respond_to?(:filtered_parameters) then request.filtered_parameters
+                   else params
+                 end
+      Rails.logger.mongoize({
+        :method         => request.method,
+        :action         => action_name,
+        :controller     => controller_name,
+        :path           => request.path,
+        :url            => request.url,
+        :params         => f_params,
+        :ip             => request.remote_ip
+      }) { yield }
+    end
+  end
+end

data/lib/mongodb_logger/initializer_mixin.rb

@@ -0,0 +1,26 @@
+module MongodbLogger
+  module InitializerMixin
+    
+    def rails30?
+      3 == Rails::VERSION::MAJOR && 0 == Rails::VERSION::MINOR
+    end
+    
+    def create_logger(config)
+      path = rails30? ? config.paths.log.to_a.first : config.paths['log'].first
+      level = ActiveSupport::BufferedLogger.const_get(config.log_level.to_s.upcase)
+      logger = MongodbLogger::Logger.new(:path => path, :level => level)
+      logger.auto_flushing = false if Rails.env.production?
+      logger
+    rescue StandardError => e
+      logger = ActiveSupport::BufferedLogger.new(STDERR)
+      logger.level = ActiveSupport::BufferedLogger::WARN
+      logger.warn(
+        "MongodbLogger Initializer Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " +
+        "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed." + "\n" +
+        e.message + "\n" + e.backtrace.join("\n")
+      )
+      logger
+    end
+    
+  end
+end

data/lib/mongodb_logger/logger.rb

@@ -0,0 +1,184 @@
+require 'erb'
+require 'mongo'
+require 'active_support'
+require 'active_support/core_ext'
+require 'mongodb_logger/replica_set_helper'
+
+module MongodbLogger
+  class Logger < ActiveSupport::BufferedLogger
+    include ReplicaSetHelper
+
+    DEFAULT_COLLECTION_SIZE = 250.megabytes
+    # Looks for configuration files in this order
+    CONFIGURATION_FILES = ["mongodb_logger.yml", "mongoid.yml", "database.yml"]
+    LOG_LEVEL_SYM = [:debug, :info, :warn, :error, :fatal, :unknown]
+
+    attr_reader :db_configuration, :mongo_connection, :mongo_collection_name, :mongo_collection
+
+    def initialize(options={})
+      path = options[:path] || File.join(Rails.root, "log/#{Rails.env}.log")
+      level = options[:level] || DEBUG
+      internal_initialize
+      if disable_file_logging?
+        @level          = level
+        @buffer         = {}
+        @auto_flushing  = 1
+        @guard          = Mutex.new
+      else
+        super(path, level)
+      end
+    rescue => e
+      # should use a config block for this
+      Rails.env.production? ? (raise e) : (puts "Using BufferedLogger due to exception: " + e.message)
+    end
+
+    def add_metadata(options={})
+      options.each do |key, value|
+        unless [:messages, :request_time, :ip, :runtime, :application_name, :is_exception, :params, :method].include?(key.to_sym)
+          @mongo_record[key] = value
+        else
+          raise ArgumentError, ":#{key} is a reserved key for the mongodb logger. Please choose a different key"
+        end
+      end
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      if @level <= severity && message.present? && @mongo_record.present?
+        # do not modify the original message used by the buffered logger
+        msg = logging_colorized? ? message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, '').strip : message
+        @mongo_record[:messages][LOG_LEVEL_SYM[severity]] << msg
+      end
+      # may modify the original message
+      disable_file_logging? ? message : super
+    end
+
+    # Drop the capped_collection and recreate it
+    def reset_collection
+      @mongo_collection.drop
+      create_collection
+    end
+
+    def mongoize(options={})
+      @mongo_record = options.merge({
+        :messages => Hash.new { |hash, key| hash[key] = Array.new },
+        :request_time => Time.now.getutc,
+        :application_name => @application_name
+      })
+
+      runtime = Benchmark.measure{ yield }.real if block_given?
+    rescue Exception => e
+      add(3, e.message + "\n" + e.backtrace.join("\n"))
+      @mongo_record[:is_exception] = true
+      # Reraise the exception for anyone else who cares
+      raise e
+    ensure
+      # In case of exception, make sure runtime is set
+      @mongo_record[:runtime] = ((runtime ||= 0) * 1000).ceil
+      begin
+        @insert_block.call
+      rescue
+        # do extra work to inpect (and flatten)
+        force_serialize @mongo_record
+        @insert_block.call rescue nil
+      end
+    end
+
+    def authenticated?
+      @authenticated
+    end
+
+    private
+      # facilitate testing
+      def internal_initialize
+        configure
+        connect
+        check_for_collection
+      end
+      
+      def disable_file_logging?
+        @db_configuration.fetch('disable_file_logging', false)
+      end
+
+      def configure
+        default_capsize = DEFAULT_COLLECTION_SIZE
+        @authenticated = false
+        @db_configuration = {
+          'host' => 'localhost',
+          'port' => 27017,
+          'capsize' => default_capsize}.merge(resolve_config)
+        @mongo_collection_name = @db_configuration[:collection] || "#{Rails.env}_log"
+        @application_name = resolve_application_name
+        @safe_insert = @db_configuration['safe_insert'] || false
+
+        @insert_block = @db_configuration.has_key?('replica_set') && @db_configuration['replica_set'] ?
+          lambda { rescue_connection_failure{ insert_log_record(@safe_insert) } } :
+          lambda { insert_log_record }
+      end
+
+      def resolve_application_name
+        if @db_configuration.has_key?('application_name')
+          @db_configuration['application_name']
+        else
+          Rails.application.class.to_s.split("::").first
+        end
+      end
+
+      def resolve_config
+        config = {}
+        CONFIGURATION_FILES.each do |filename|
+          config_file = Rails.root.join("config", filename)
+          if config_file.file?
+            config = YAML.load(ERB.new(config_file.read).result)[Rails.env]
+            config = config['mongodb_logger'] if config && config.has_key?('mongodb_logger')
+            break unless config.blank?
+          end
+        end
+        config
+      end
+
+      def connect
+        @mongo_connection ||= Mongo::Connection.new(@db_configuration['host'],
+                                                    @db_configuration['port'],
+                                                    :auto_reconnect => true).db(@db_configuration['database'])
+
+        if @db_configuration['username'] && @db_configuration['password']
+          # the driver stores credentials in case reconnection is required
+          @authenticated = @mongo_connection.authenticate(@db_configuration['username'],
+                                                          @db_configuration['password'])
+        end
+      end
+
+      def create_collection
+        @mongo_connection.create_collection(@mongo_collection_name,
+                                            {:capped => true, :size => @db_configuration['capsize']})
+      end
+
+      def check_for_collection
+        # setup the capped collection if it doesn't already exist
+        create_collection unless @mongo_connection.collection_names.include?(@mongo_collection_name)
+        @mongo_collection = @mongo_connection[@mongo_collection_name]
+      end
+
+      def insert_log_record(safe = false)
+        @mongo_collection.insert(@mongo_record, :safe => safe)
+      end
+
+      def logging_colorized?
+        # Cache it since these ActiveRecord attributes are assigned after logger initialization occurs in Rails boot
+        @colorized ||= Object.const_defined?(:ActiveRecord) && ActiveRecord::LogSubscriber.colorize_logging
+      end
+
+      # force the data in the db by inspecting each top level array and hash element
+      # this will flatten other hashes and arrays
+      def force_serialize(rec)
+        if msgs = rec[:messages]
+          LOG_LEVEL_SYM.each do |i|
+            msgs[i].collect! { |j| j.inspect } if msgs[i]
+          end
+        end
+        if pms = rec[:params]
+          pms.each { |i, j| pms[i] = j.inspect }
+        end
+      end
+  end
+end