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

mongodb_logger 0.2.6-jruby

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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