mongodb_logger 0.1.0

data/test/rails/app/controllers/order_controller.rb

@@ -0,0 +1,20 @@
+class OrderController < ApplicationController
+  include MongodbLogger::Base
+  LOG_MESSAGE = "FOO"
+  LOG_USER_ID = 12345
+
+  def index
+    logger.debug LOG_MESSAGE
+    logger.add_metadata(:application_name_again => Rails.root.basename.to_s)
+    logger.add_metadata(:user_id => LOG_USER_ID)
+    render :text => "nothing"
+  end
+
+  def new
+    raise OrderController::LOG_MESSAGE
+  end
+
+  def create
+    render :text => "create"
+  end
+end

data/test/rails/test/functional/order_controller_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+class OrderControllerTest < ActionController::TestCase
+  def setup
+    @mongodb_logger = Rails.logger
+    @mongodb_logger.reset_collection
+    common_setup
+  end
+
+  test "should have log level set" do
+    assert_equal ActiveSupport::BufferedLogger.const_get(Rails.configuration.log_level.to_s.upcase), Rails.logger.level
+  end
+
+  test "should have auto flushing set in development" do
+    assert @mongodb_logger.auto_flushing
+  end
+
+  test "should log a single record" do
+    get :index
+    assert_response :success
+    assert_equal 1, @collection.find({"controller" => "order","action"=> "index"}).count
+  end
+
+  test "should log a debug message" do
+    get :index
+    assert_equal OrderController::LOG_MESSAGE, @collection.find_one({}, :fields => ["messages"])["messages"]["debug"][0]
+  end
+
+  test "should log extra metadata" do
+    get :index
+    assert_equal Rails.root.basename.to_s, @collection.find_one({}, :fields => "application_name_again")["application_name_again"]
+    assert_equal OrderController::LOG_USER_ID, @collection.find_one({}, :fields => "user_id")["user_id"]
+  end
+  
+  test "should log request parameters" do
+    get :index
+    log = @collection.find_one()
+    http_method = 'GET'
+    assert_equal http_method, log['method']
+  end
+
+  test "should log exceptions" do
+    assert_raise(RuntimeError, OrderController::LOG_MESSAGE) {get :new}
+    assert_equal 1, @collection.find_one({"messages.error" => /^#{OrderController::LOG_MESSAGE}/})["messages"]["error"].count
+    assert_equal 1, @collection.find_one({"is_exception" => true})["messages"]["error"].count
+  end
+
+  test "should not log passwords" do
+    post :create, :order => {:password => OrderController::LOG_MESSAGE }
+    assert_equal 1, @collection.find_one({"params.order.password" => "[FILTERED]"})["params"]["order"].count
+  end
+
+  test "should set the application name" do
+    assert_equal 'mongo_foo', @mongodb_logger.instance_variable_get(:@application_name)
+  end
+end

data/test/rails/test/test_helper.rb

@@ -0,0 +1,10 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  def common_setup
+    @con = @mongodb_logger.mongo_connection
+    @collection = @con[@mongodb_logger.mongo_collection_name]
+  end
+end

data/test/shoulda_macros/log_macros.rb

@@ -0,0 +1,13 @@
+module LogMacros
+  def should_contain_one_log_record
+    should "contain a log record" do
+      assert_equal 1, @con[@mongodb_logger.mongo_collection_name].count
+    end
+  end
+
+  def should_use_database_name_in_config
+    should "use the database name in the config file" do
+      assert_equal "system_log", @mongodb_logger.db_configuration['database']
+    end
+  end
+end

data/test/test.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+rake vendor_test_gems
+rake test
+rake cucumber:rails:all

data/test/test_helper.rb

@@ -0,0 +1,88 @@
+require 'test/unit'
+
+begin
+  require 'shoulda'
+rescue LoadError
+  require 'rubygems'
+  require 'shoulda'
+end
+
+require 'mocha'
+# mock rails class
+require 'pathname'
+require 'rails'
+require 'fileutils'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+Shoulda.autoload_macros("#{File.dirname(__FILE__)}/..")
+
+class Test::Unit::TestCase
+  CONFIG_DIR = Rails.root.join("config")
+  SAMPLE_CONFIG_DIR = File.join(CONFIG_DIR, "samples")
+  DEFAULT_CONFIG = "database.yml"
+  DEFAULT_CONFIG_WITH_AUTH = "database_with_auth.yml"
+  DEFAULT_CONFIG_WITH_NO_FILE_LOGGING = "database_no_file_logging.yml"
+  MONGOID_CONFIG = "mongoid.yml"
+  REPLICA_SET_CONFIG = "database_replica_set.yml"
+  LOGGER_CONFIG = "mongodb_logger.yml"
+
+  def log(msg)
+    @mongodb_logger.mongoize({"id" => 1}) do
+      @mongodb_logger.debug(msg)
+    end
+  end
+
+  def log_params(msg)
+    @mongodb_logger.mongoize({:params => msg})
+  end
+
+  def log_exception(msg)
+    @mongodb_logger.mongoize({"id" => 1}) do
+      raise msg
+    end
+  end
+
+  def setup_for_config(source, dest=source)
+    File.delete(File.join(CONFIG_DIR, DEFAULT_CONFIG))
+    cp_config(source, dest)
+    @mongodb_logger.send(:configure)
+  end
+
+  def cp_config(source, dest=source)
+    FileUtils.cp(File.join(SAMPLE_CONFIG_DIR, source),  File.join(CONFIG_DIR, dest))
+  end
+
+  def teardown_for_config(file)
+    File.delete(File.join(CONFIG_DIR, file))
+  end
+
+  def log_metadata(options)
+    @mongodb_logger.mongoize({"id" => 1}) do
+      @mongodb_logger.add_metadata(options)
+    end
+  end
+
+  def require_bogus_active_record
+    require 'active_record'
+  end
+
+  def common_setup
+    @con = @mongodb_logger.mongo_connection
+    @collection = @con[@mongodb_logger.mongo_collection_name]
+  end
+
+  def create_user
+    db_conf = @mongodb_logger.db_configuration
+    @user = db_conf['username']
+    mongo_connection = Mongo::Connection.new(db_conf['host'],
+                                             db_conf['port']).db(db_conf['database'])
+    mongo_connection.add_user(@user, db_conf['password'])
+  end
+
+  def remove_user
+    @mongodb_logger.mongo_connection.remove_user(@user)
+  end
+
+end

data/test/unit/mongodb_logger_replica_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+require 'mongodb_logger/logger'
+
+# test the basic stuff
+class MongodbLogger::MongodbLoggerReplicaTest < Test::Unit::TestCase
+  extend LogMacros
+
+  context "A MongodbLogger::MongoLogger" do
+    setup do
+      # Can use different configs, but most tests use database.yml
+      cp_config(REPLICA_SET_CONFIG, DEFAULT_CONFIG)
+      @mongodb_logger = MongodbLogger::Logger.new
+      @mongodb_logger.reset_collection
+    end
+
+    context "upon trying to insert into a replica set voting on a new master" do
+      setup do
+        puts "Please disconnect the current master and hit ENTER"
+        STDIN.gets
+      end
+
+      should "insert a record successfully" do
+        assert_nothing_raised{ log("Test") }
+        @mongodb_logger.rescue_connection_failure do
+          assert_equal 1, @mongodb_logger.mongo_collection.count
+        end
+      end
+
+      teardown do
+        puts "Please reconnect the current master, wait for the vote to complete, then hit ENTER"
+        STDIN.gets
+      end
+    end
+
+    should "insert a record successfully" do
+      assert_nothing_raised{ log("Test") }
+      assert_equal 1, @mongodb_logger.mongo_collection.count
+    end
+
+    teardown do
+      file = File.join(CONFIG_DIR, DEFAULT_CONFIG)
+      File.delete(file) if File.exist?(file)
+    end
+  end
+end

data/test/unit/mongodb_logger_test.rb

@@ -0,0 +1,252 @@
+require 'test_helper'
+require 'mongodb_logger/logger'
+require 'tempfile'
+require 'pathname'
+
+# test the basic stuff
+class MongodbLogger::LoggerTest < Test::Unit::TestCase
+  extend LogMacros
+
+  EXCEPTION_MSG = "Foo"
+
+  context "A MongodbLogger::Logger" do
+    setup do
+      # Can use different configs, but most tests use database.yml
+      FileUtils.cp(File.join(SAMPLE_CONFIG_DIR, DEFAULT_CONFIG),  CONFIG_DIR)
+    end
+
+    context "in instantiation" do
+      setup do
+        MongodbLogger::Logger.any_instance.stubs(:internal_initialize).returns(nil)
+        MongodbLogger::Logger.any_instance.stubs(:disable_file_logging?).returns(false)
+        @mongodb_logger = MongodbLogger::Logger.new
+      end
+
+      context "during configuration when using a separate " + LOGGER_CONFIG do
+        setup do
+          setup_for_config(LOGGER_CONFIG)
+        end
+
+        should_use_database_name_in_config
+
+        teardown do
+          teardown_for_config(LOGGER_CONFIG)
+        end
+      end
+
+      context "during configuration when using a separate " + MONGOID_CONFIG do
+        setup do
+          setup_for_config(MONGOID_CONFIG)
+        end
+
+        should_use_database_name_in_config
+
+        teardown do
+          teardown_for_config(MONGOID_CONFIG)
+        end
+      end
+
+      # this test will work without the --auth mongod arg
+      context "upon connecting with authentication settings" do
+        setup do
+          setup_for_config(DEFAULT_CONFIG_WITH_AUTH, DEFAULT_CONFIG)
+          create_user
+        end
+
+        should "authenticate with the credentials in the configuration" do
+          @mongodb_logger.send(:connect)
+          assert @mongodb_logger.authenticated?
+        end
+
+        teardown do
+          # config will be deleted by outer teardown
+          remove_user
+        end
+      end
+
+      context "after configuration" do
+        setup do
+          @mongodb_logger.send(:configure)
+        end
+
+        should "set the default host, port, and capsize if not configured" do
+          assert_equal 'localhost', @mongodb_logger.db_configuration['host']
+          assert_equal 27017, @mongodb_logger.db_configuration['port']
+          assert_equal MongodbLogger::Logger::DEFAULT_COLLECTION_SIZE, @mongodb_logger.db_configuration['capsize']
+        end
+
+        should "set the mongo collection name depending on the Rails environment" do
+          assert_equal "#{Rails.env}_log", @mongodb_logger.mongo_collection_name
+        end
+
+        should "set the application name when specified in the config file" do
+          assert_equal "mongo_foo", @mongodb_logger.instance_variable_get(:@application_name)
+        end
+
+        should "set safe insert when specified in the config file" do
+          assert @mongodb_logger.instance_variable_get(:@safe_insert)
+        end
+
+        should "use the database name in the config file" do
+          assert_equal "system_log", @mongodb_logger.db_configuration['database']
+        end
+
+        context "upon connecting to an empty database" do
+          setup do
+            @mongodb_logger.send(:connect)
+            common_setup
+            @collection.drop
+          end
+
+          should "expose a valid mongo connection" do
+            assert_instance_of Mongo::DB, @mongodb_logger.mongo_connection
+          end
+
+          should "not authenticate" do
+            assert !@mongodb_logger.authenticated?
+          end
+
+          should "create a capped collection in the database with the configured size" do
+            @mongodb_logger.send(:check_for_collection)
+            assert @con.collection_names.include?(@mongodb_logger.mongo_collection_name)
+            # new capped collections are X MB + 5888 bytes, but don't be too strict in case that changes
+            assert @collection.stats["storageSize"] < MongodbLogger::Logger::DEFAULT_COLLECTION_SIZE + 1.megabyte
+          end
+        end
+      end
+    end
+
+    context "after instantiation" do
+      setup do
+        @mongodb_logger = MongodbLogger::Logger.new
+        common_setup
+        @mongodb_logger.reset_collection
+      end
+
+      context "upon insertion of a log record when active record is not used" do
+        # mock ActiveRecord has not been included
+        setup do
+          log("Test")
+        end
+
+        should_contain_one_log_record
+
+        should "allow recreation of the capped collection to remove all records" do
+          @mongodb_logger.reset_collection
+          assert_equal 0, @collection.count
+        end
+      end
+
+      context "upon insertion of a colorized log record when ActiveRecord is used" do
+        setup do
+          @log_message = "TESTING"
+          require_bogus_active_record
+          log("\e[31m #{@log_message} \e[0m")
+        end
+
+        should "detect logging is colorized" do
+          assert @mongodb_logger.send(:logging_colorized?)
+        end
+
+        should_contain_one_log_record
+
+        should "strip out colorization from log messages" do
+          assert_equal 1, @collection.find({"messages.debug" => @log_message}).count
+        end
+      end
+
+      should "add application metadata to the log record" do
+        options = {"application" => self.class.name}
+        log_metadata(options)
+        assert_equal 1, @collection.find({"application" => self.class.name}).count
+      end
+
+      should "not raise an exception when bson-unserializable data is logged in the :messages key" do
+        log(Tempfile.new("foo"))
+        assert_equal 1, @collection.count
+      end
+
+      should "not raise an exception when bson-unserializable data is logged in the :params key" do
+        log_params({:foo => Tempfile.new("bar")})
+        assert_equal 1, @collection.count
+      end
+
+      context "when an exception is raised" do
+        should "log the exception" do
+          assert_raise(RuntimeError, EXCEPTION_MSG) {log_exception(EXCEPTION_MSG)}
+          assert_equal 1, @collection.find_one({"messages.error" => /^#{EXCEPTION_MSG}/})["messages"]["error"].count
+          assert_equal 1, @collection.find_one({"is_exception" => true})["messages"]["error"].count
+        end
+      end
+    end
+
+    context "logging at INFO level" do
+      setup do
+        @mongodb_logger = MongodbLogger::Logger.new(:level => MongodbLogger::Logger::INFO)
+        common_setup
+        @mongodb_logger.reset_collection
+        log("INFO")
+      end
+
+      should_contain_one_log_record
+
+      should "not log DEBUG messages" do
+        assert_equal 0, @collection.find_one({}, :fields => ["messages"])["messages"].count
+      end
+    end
+    teardown do
+      file = File.join(CONFIG_DIR, DEFAULT_CONFIG)
+      File.delete(file) if File.exist?(file)
+    end
+  end
+  
+  context "A MongodbLogger::Logger without file logging" do
+    setup do
+      FileUtils.cp(File.join(SAMPLE_CONFIG_DIR, DEFAULT_CONFIG_WITH_NO_FILE_LOGGING),  File.join(CONFIG_DIR, DEFAULT_CONFIG))
+      @log_file = Pathname.new('log.out')
+      FileUtils.touch(@log_file)
+    end
+
+    context "in instantiation" do
+      should "not call super in the initialize method" do
+        MongodbLogger::Logger.any_instance.expects(:open).never # Stubbing out super doesn't work, so we use this side effect instead.
+        MongodbLogger::Logger.new
+      end
+
+      should "set level" do
+        level = stub('level')
+        logger = MongodbLogger::Logger.new(:level => level)
+        assert_equal level, logger.level
+      end
+      should "set buffer" do
+        assert_equal({}, MongodbLogger::Logger.new.instance_variable_get(:@buffer))
+      end
+      should "set auto flushing" do
+        assert_equal 1, MongodbLogger::Logger.new.instance_variable_get(:@auto_flushing)
+      end
+      should "set guard" do
+        assert MongodbLogger::Logger.new.instance_variable_get(:@guard).is_a?(Mutex)
+      end
+    end
+
+    context "after instantiation" do
+      context "upon insertion of a log record" do
+        setup do
+          @mongodb_logger = MongodbLogger::Logger.new(:path => @log_file)
+          log("Test")
+        end
+
+        should "not log the record to a file" do
+          assert_equal '', open(@log_file).read
+        end
+      end
+    end
+
+    teardown do
+      file = File.join(CONFIG_DIR, DEFAULT_CONFIG)
+      File.delete(file) if File.exist?(file)
+      File.delete(@log_file)
+    end
+  end
+  
+end