RubyGems - mongodb_logger - Versions diffs - 0.2.6-jruby - Mend

mongodb_logger 0.2.6-jruby

Files changed (118) hide show

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

@@ -0,0 +1,116 @@
+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 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 write GET request method" do
+    get :index
+    log = @collection.find_one()
+    http_method = 'GET'
+    assert_equal http_method, log['method']
+  end
+  test "should write POST request method" do
+    post :create
+    log = @collection.find_one()
+    http_method = 'POST'
+    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 log find by params keys" do
+    some_name = "name"
+    post :create, :activity => {:name =>  some_name}
+    assert_equal 1, @collection.find({"params.activity.name" => some_name}).count
+  end
+  test "should search any values by params keys" do
+    post :test_post, :data => {
+      :int => 1,
+      :is_true => true,
+      :is_false => false,
+      :string => "string",
+      :push_hash => { :yes => "yes" },
+      :float => 1.22
+    }
+    # such testing down on Rails 3.1.x, because in tests params converte Fixnum values into String
+    # :(
+    # assert_equal 1, @collection.find({"params.data.int" => 1}).count
+    # data types
+    assert_equal 1, @collection.find({"params.data.is_true" => true}).count
+    assert_equal 1, @collection.find({"params.data.is_false" => false}).count
+    assert_equal 1, @collection.find({"params.data.string" => "string"}).count
+    assert_equal 1, @collection.find({"params.data.push_hash.yes" => "yes"}).count
+  end
+  test "should search any values by params keys with attachments" do
+    filepath = "mltest_file.html"
+    content_type = "text/html"
+    tmpfile = File.open("#{ActionController::TestCase.fixture_path}#{filepath}", 'w') {|f| f.write("<html></html>") }
+    uploaded_file = fixture_file_upload(filepath, content_type, :binary)
+    post :test_post, :data => {
+      :some_key => [
+        {:file => uploaded_file}
+      ],
+      :int => 1,
+      :is_true => true,
+      :is_false => false,
+      :string => "string",
+      :push_hash => { :yes => "yes" },
+      :float => 1.22
+    }
+    # data types
+    assert_equal 1, @collection.find({"params.data.is_true" => true}).count
+    assert_equal 1, @collection.find({"params.data.is_false" => false}).count
+    assert_equal 1, @collection.find({"params.data.string" => "string"}).count
+    assert_equal 1, @collection.find({"params.data.push_hash.yes" => "yes"}).count
+    # attachment
+    assert_equal 1, @collection.find({"params.data.some_key.file.content_type" => content_type}).count
+    assert_equal 1, @collection.find({"params.data.some_key.file.original_filename" => filepath}).count
+    File.delete(filepath) if File.exist?(filepath)
+  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 ADDED Viewed

@@ -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/rails.rb ADDED Viewed

@@ -0,0 +1,22 @@
+module MongodbLogger
+  class Application
+  end
+end
+class Rails
+  module VERSION
+    MAJOR = 3
+  end
+  def self.env
+    ActiveSupport::StringInquirer.new("test")
+  end
+  def self.root
+    Pathname.new(File.dirname(__FILE__))
+  end
+  def self.application
+    MongodbLogger::Application.new
+  end
+end

data/test/shoulda_macros/log_macros.rb ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,6 @@
+#!/bin/bash
+rake vendor_test_gems && \
+rake test && \
+rake cucumber:web && \
+rake jasmine:ci && \
+rake cucumber:rails:all

data/test/test_helper.rb ADDED Viewed

@@ -0,0 +1,89 @@
+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_COLLECTION = "database_with_collection.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 ADDED Viewed

@@ -0,0 +1,56 @@
+require 'test_helper'
+require 'mongodb_logger/logger'
+# HOWTO run this test:
+# before start this test, do this in console:
+# mkdir -p /tmp/data1
+# mkdir -p /tmp/data2
+# mkdir -p /tmp/data3
+# mongod --replSet foo --port 27018 --dbpath /tmp/data1
+# mongod --replSet foo --port 27019 --dbpath /tmp/data2
+# mongod --replSet foo --port 27020 --dbpath /tmp/data3
+# mongo localhost:27018
+# In mongo console:
+# config = {_id: 'foo', members: [
+# {_id: 0, host: 'localhost:27018'},
+# {_id: 1, host: 'localhost:27019'},
+# {_id: 2, host: 'localhost:27020', arbiterOnly: true}]
+# }
+#
+# rs.initiate(config);
+# You should see such output:
+# {
+#         "info" : "Config now saved locally.  Should come online in about a minute.",
+#         "ok" : 1
+# }
+class MongodbLogger::MongodbLoggerReplicaTest < Test::Unit::TestCase
+  extend LogMacros
+  context "A MongodbLogger::MongoLogger connecting to a replica set" do
+    setup do
+      FileUtils.cp(File.join(SAMPLE_CONFIG_DIR, REPLICA_SET_CONFIG),  File.join(CONFIG_DIR, DEFAULT_CONFIG))
+      MongodbLogger::Logger.any_instance.stubs(:internal_initialize).returns(nil)
+      MongodbLogger::Logger.any_instance.stubs(:disable_file_logging?).returns(false)
+      @mongodb_logger = MongodbLogger::Logger.new
+      @mongodb_logger.send(:configure)
+      @mongodb_logger.send(:connect)
+      common_setup
+      @collection.drop
+    end
+    should "derive from Mongo::ReplSetConnection" do
+      assert_equal Mongo::ReplSetConnection, @mongodb_logger.mongo_connection_type
+    end
+    should "force replica_set parameter to be true" do
+      assert @mongodb_logger.db_configuration['replica_set']
+    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 ADDED Viewed

@@ -0,0 +1,270 @@
+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 "derive from Mongo::Connection for single host" do
+            assert_equal Mongo::Connection, @mongodb_logger.mongo_connection_type
+          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 buffer" do
+        assert_equal({}, MongodbLogger::Logger.new.instance_variable_get(:@buffer))
+      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
+  context "A MongodbLogger::Logger with custom collection" do
+    setup do
+      file_path = File.join(SAMPLE_CONFIG_DIR, DEFAULT_CONFIG_WITH_COLLECTION)
+      FileUtils.cp(file_path,  File.join(CONFIG_DIR, DEFAULT_CONFIG))
+      @mongodb_logger = MongodbLogger::Logger.new
+      common_setup
+      @mongodb_logger.reset_collection
+      @file_config = YAML.load(ERB.new(File.new(file_path).read).result)[Rails.env]['mongodb_logger']
+    end
+    should "changed collection name" do
+      assert_equal @file_config['collection'], @mongodb_logger.mongo_collection_name
+      assert_equal "#{@file_config['database']}.#{@file_config['collection']}", @collection.stats()['ns']
+    end
+    teardown do
+      file = File.join(CONFIG_DIR, DEFAULT_CONFIG)
+      File.delete(file) if File.exist?(file)
+    end
+  end
+end