central_logger 0.1.1 → 0.2.0

data/Gemfile

@@ -5,12 +5,6 @@ gem "bundler", "~> 1.0.0"
 gem "mongo"
 gem "bson_ext"
 
-group :production do
-  # don't want to force development to have this requirement, because every
-  # Rails dependency is mocked
-  gem "rails",">= 2.3.8"
-end
-
 group :development do
   # adds Bundler support for gemspec generation
   gem "jeweler", "~> 1.5.0.pre5"

data/Gemfile.lock

@@ -1,42 +1,11 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    abstract (1.0.0)
-    actionmailer (3.0.1)
-      actionpack (= 3.0.1)
-      mail (~> 2.2.5)
-    actionpack (3.0.1)
-      activemodel (= 3.0.1)
-      activesupport (= 3.0.1)
-      builder (~> 2.1.2)
-      erubis (~> 2.6.6)
-      i18n (~> 0.4.1)
-      rack (~> 1.2.1)
-      rack-mount (~> 0.6.12)
-      rack-test (~> 0.5.4)
-      tzinfo (~> 0.3.23)
-    activemodel (3.0.1)
-      activesupport (= 3.0.1)
-      builder (~> 2.1.2)
-      i18n (~> 0.4.1)
-    activerecord (3.0.1)
-      activemodel (= 3.0.1)
-      activesupport (= 3.0.1)
-      arel (~> 1.0.0)
-      tzinfo (~> 0.3.23)
-    activeresource (3.0.1)
-      activemodel (= 3.0.1)
-      activesupport (= 3.0.1)
     activesupport (3.0.1)
     archive-tar-minitar (0.5.2)
-    arel (1.0.1)
-      activesupport (~> 3.0.0)
-    bson (1.1.1)
-    bson_ext (1.1.1)
-    builder (2.1.2)
-    columnize (0.3.1)
-    erubis (2.6.6)
-      abstract (>= 1.0.0)
+    bson (1.1.2)
+    bson_ext (1.1.2)
+    columnize (0.3.2)
     git (1.2.5)
     i18n (0.4.2)
     jeweler (1.5.0.pre5)
@@ -45,35 +14,10 @@ GEM
       rake
     linecache19 (0.5.11)
       ruby_core_source (>= 0.1.4)
-    mail (2.2.9)
-      activesupport (>= 2.3.6)
-      i18n (~> 0.4.1)
-      mime-types (~> 1.16)
-      treetop (~> 1.4.8)
-    mime-types (1.16)
     mocha (0.9.9)
       rake
-    mongo (1.1.1)
+    mongo (1.1.2)
       bson (>= 1.1.1)
-    polyglot (0.3.1)
-    rack (1.2.1)
-    rack-mount (0.6.13)
-      rack (>= 1.0.0)
-    rack-test (0.5.6)
-      rack (>= 1.0)
-    rails (3.0.1)
-      actionmailer (= 3.0.1)
-      actionpack (= 3.0.1)
-      activerecord (= 3.0.1)
-      activeresource (= 3.0.1)
-      activesupport (= 3.0.1)
-      bundler (~> 1.0.0)
-      railties (= 3.0.1)
-    railties (3.0.1)
-      actionpack (= 3.0.1)
-      activesupport (= 3.0.1)
-      rake (>= 0.8.4)
-      thor (~> 0.14.0)
     rake (0.8.7)
     ruby-debug-base19 (0.11.24)
       columnize (>= 0.3.1)
@@ -86,10 +30,6 @@ GEM
     ruby_core_source (0.1.4)
       archive-tar-minitar (>= 0.5.2)
     shoulda (2.11.3)
-    thor (0.14.3)
-    treetop (1.4.8)
-      polyglot (>= 0.3.1)
-    tzinfo (0.3.23)
 
 PLATFORMS
   ruby
@@ -102,7 +42,6 @@ DEPENDENCIES
   jeweler (~> 1.5.0.pre5)
   mocha
   mongo
-  rails (>= 2.3.8)
   rake
   ruby-debug19
   shoulda

data/README.md

@@ -21,7 +21,11 @@ Log to a central MongoDB from Rails apps.
        require 'central_logger'
        CentralLogger::Initializer.initialize_deprecated_logger(config)
 
-1. Add mongo settings to database.yml for each environment in which you want to use the Central Logger for logging. The values below are defaults:
+1. Add mongo settings to database.yml for each environment in which you want to use the Central Logger. The central logger will also
+   look for a separate central_logger.yml or mongoid.yml (if you are using mongoid) before looking in database.yml.
+   In the central_logger.yml and mongoid.yml case, the settings should be defined without the 'mongo' subkey.
+
+   database.yml:
 
         development:
           adapter: mysql
@@ -33,13 +37,21 @@ Log to a central MongoDB from Rails apps.
             host: localhost                # default: localhost
             port: 27017                    # default: 27017
 
+    central_logger.yml:
+
+        development:
+          database: my_app
+          capsize: <%= 10.megabytes %>
+          host: localhost
+          port: 27017
+
   With that in place, a new MongoDB document (record) will be created for each request and,
   by default will record the following information: Runtime, IP Address, Request Time, Controller,
   Action, Params, Application Name and All messages sent to the logger. The structure of the Mongo document looks like this:
 
         {
           'action'           : action_name,
-          'application_name' : action_name,
+          'application_name' : application_name (rails root),
           'controller'       : controller_name,
           'ip'               : ip_address,
           'messages'         : {
@@ -97,4 +109,8 @@ Find all requests with an exception that contains "RoutingError" in the message
 
     >> collection.find({"messages.error" => /RoutingError/})
 
+Find all requests with a request_date greater than '11/18/2010 22:59:52 GMT'
+
+    >> collection.find({:request_time => {'$gt' => Time.utc(2010, 11, 18, 22, 59, 52)}})
+
 Copyright (c) 2009 Phil Burrows, released under the MIT license

data/Rakefile

@@ -6,8 +6,8 @@ require 'bundler'
 require 'jeweler'
 
 desc 'Default: run unit tests.'
-task :default => :test
-task :test => :check_dependencies
+task :default => "test:units"
+task :test => "test:functionals"
 
 begin
   Bundler.setup(:default, :development)
@@ -24,13 +24,39 @@ Jeweler::Tasks.new do |gem|
   gem.email = "astupka@customink.com"
   gem.homepage = "http://github.com/customink/central_logger"
   gem.authors = ["Phil Burrows", "Alex Stupka"]
+  gem.files.exclude 'test/rails/**/*'
+  gem.test_files.exclude 'test/rails/**/*'
 end
 # dependencies defined in Gemfile
 
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
+def rake_functionals(opts=nil)
+    if ENV['RUBYOPT']
+      # remove bundler/setup require that prematurely checks for gems and crashes
+      ENV['RUBYOPT'] = ENV['RUBYOPT'].gsub(%r{-r\s*bundler/setup}, '')
+    end
+    # runs all the tests for each ruby version in each rails dir
+    system("bash test/test.sh #{opts}")
+end
+
+namespace :test do
+  desc "Run all tests against all permutations of ruby and rails"
+  task :functionals do
+    rake_functionals
+  end
+
+  namespace :functionals do
+    desc "Clean out gemsets before running functional tests."
+    task :clean do
+      rake_functionals('--clean')
+    end
+  end
+
+  desc "Run unit tests"
+  Rake::TestTask.new(:units) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/unit/*_test.rb'
+    test.verbose = true
+  end
 end
 
 Rake::RDocTask.new do |rdoc|

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/central_logger.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{central_logger}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Phil Burrows", "Alex Stupka"]
-  s.date = %q{2010-11-03}
+  s.date = %q{2010-11-30}
   s.description = %q{Centralized logging for rails apps using MongoDB. The idea and the core code is from http://github.com/peburrows/central_logger}
   s.email = %q{astupka@customink.com}
   s.extra_rdoc_files = [
@@ -29,11 +29,15 @@ Gem::Specification.new do |s|
     "lib/central_logger/initializer.rb",
     "lib/central_logger/initializer_mixin.rb",
     "lib/central_logger/mongo_logger.rb",
-    "lib/railtie.rb",
+    "lib/central_logger/railtie.rb",
     "test/active_record.rb",
-    "test/config/database.yml",
+    "test/config/samples/central_logger.yml",
+    "test/config/samples/database.yml",
+    "test/config/samples/database_with_auth.yml",
+    "test/config/samples/mongoid.yml",
     "test/rails.rb",
     "test/shoulda_macros/log_macros.rb",
+    "test/test.sh",
     "test/test_helper.rb",
     "test/unit/central_logger_test.rb"
   ]

data/lib/central_logger.rb

@@ -4,5 +4,5 @@ require 'mongo'
 require 'central_logger/mongo_logger'
 require 'central_logger/filter'
 require 'central_logger/initializer'
-require 'railtie'
+require 'central_logger/railtie'
 

data/lib/central_logger/filter.rb

@@ -7,8 +7,12 @@ module CentralLogger
     def enable_central_logger
       return yield unless Rails.logger.respond_to?(:mongoize)
 
-      # make sure the controller knows how to filter its parameters
-      f_params = respond_to?(:filter_parameters) ? filter_parameters(params) : params
+      # make sure the controller knows how to filter its parameters (Rails 3, 2, respectively)
+      f_params = case
+                   when request.respond_to?(:filtered_parameters) then request.filtered_parameters
+                   when respond_to?(:filter_parameters) then filter_parameters(params)
+                   else params
+                 end
       Rails.logger.mongoize({
         :action         => action_name,
         :controller     => controller_name,

data/lib/central_logger/mongo_logger.rb

@@ -7,6 +7,8 @@ module CentralLogger
   class MongoLogger < ActiveSupport::BufferedLogger
     PRODUCTION_COLLECTION_SIZE = 250.megabytes
     DEFAULT_COLLECTION_SIZE = 100.megabytes
+    # Looks for configuration files in this order
+    CONFIGURATION_FILES = ["central_logger.yml", "mongoid.yml", "database.yml"]
 
     attr_reader :db_configuration, :mongo_connection, :mongo_collection_name
 
@@ -16,9 +18,8 @@ module CentralLogger
       super(path, level)
       internal_initialize
     rescue => e
-      # in case the logger is fouled up use stdout
-      puts "=> !! A connection to mongo could not be established - the logger will function like a normal ActiveSupport::BufferedLogger !!"
-      puts e.message + "\n" + e.backtrace.join("\n")
+      # 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={})
@@ -64,6 +65,10 @@ module CentralLogger
       insert_log_record(runtime)
     end
 
+    def authenticated?
+      @authenticated
+    end
+
     private
       # facilitate testing
       def internal_initialize
@@ -74,21 +79,38 @@ module CentralLogger
 
       def configure
         default_capsize = Rails.env.production? ? PRODUCTION_COLLECTION_SIZE : DEFAULT_COLLECTION_SIZE
-        user_config = YAML::load(ERB.new(IO.read(File.join(Rails.root, 'config/database.yml'))).result)[Rails.env]['mongo'] || {}
         @application_name = Rails.root.basename.to_s
-
         @mongo_collection_name = "#{Rails.env}_log"
-
+        @authenticated = false
         @db_configuration = {
           'host' => 'localhost',
           'port' => 27017,
-          'capsize' => default_capsize}.merge(user_config)
+          'capsize' => default_capsize}.merge(resolve_config)
+      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['mongo'] if config.has_key?('mongo')
+            break
+          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
@@ -120,7 +142,7 @@ module CentralLogger
       end
 
       def logging_colorized?
-        # Cache it since these ActiveRecord attributes are assigned after logger initialization occurs
+        # Cache it since these ActiveRecord attributes are assigned after logger initialization occurs in Rails boot
         @colorized ||= Object.const_defined?(:ActiveRecord) &&
         (Rails::VERSION::MAJOR >= 3 ?
           ActiveRecord::LogSubscriber.colorize_logging :

data/test/config/samples/central_logger.yml

@@ -0,0 +1,2 @@
+test:
+  database: system_log

data/test/config/samples/database_with_auth.yml

@@ -0,0 +1,8 @@
+test:
+  adapter: mysql
+  username: user
+  database: database
+  mongo:
+    database: system_log
+    username: admin
+    password: password

data/test/config/samples/mongoid.yml

@@ -0,0 +1,31 @@
+# taken from http://mongoid.org/docs/installation/
+defaults: &defaults
+  host: localhost
+  slaves:
+    - host: slave1.local
+      port: 27018
+    - host: slave2.local
+      port: 27019
+  autocreate_indexes: false
+  allow_dynamic_fields: true
+  include_root_in_json: false
+  parameterize_keys: true
+  persist_in_safe_mode: false
+  raise_not_found_error: true
+  reconnect_time: 3
+
+development:
+  <<: *defaults
+  database: control_development
+
+test:
+  <<: *defaults
+  database: system_log
+
+# set these environment variables on your prod server
+production:
+  <<: *defaults
+  host: <%= ENV['MONGOID_HOST'] %>
+  port: <%= ENV['MONGOID_PORT'] %>
+  database: <%= ENV['MONGOID_DATABASE'] %>
+

data/test/shoulda_macros/log_macros.rb

@@ -4,4 +4,10 @@ module LogMacros
       assert_equal 1, @con[@central_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", @central_logger.db_configuration['database']
+    end
+  end
 end

data/test/test.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+#  This script uses rvm and gemsets to test the gem against all versions of ruby
+#  (RUBY_VERSIONS) and all rails versions in the test/rails directories
+#  (RAILS_VERSIONS).
+
+# If these aren't unset, bundler always uses them to find itself and the
+# root project gemfile
+unset BUNDLE_BIN_PATH
+unset BUNDLE_GEMFILE
+
+RAILS_VERSIONS='2 3'
+RUBY_VERSIONS='1.8.7 1.9.2'
+PROJECT_GEMSET='central_logger'
+RAILS_DIR=rails
+RAILS_RAKE_TASK_MODIFIER=':functionals'
+RAKE_UNIT_TASK_MODIFIER=':units'
+CLEAN=0
+VALID_OPT='--clean'
+
+function usage() {
+   echo 'Usage:  ' $0 "[${VALID_OPT}]"
+   echo 'Options:' $VALID_OPT 'Delete and recreate all gemsets before running tests'
+   exit 1
+}
+
+ARG=$1
+if [ $# -gt 1 ] || [ ${ARG:-$VALID_OPT} != $VALID_OPT ]; then
+  usage
+elif [ -n "$1" ]; then
+  CLEAN=1
+fi
+
+# Load RVM into a shell session *as a function*
+if [[ -s "$HOME/.rvm/scripts/rvm" ]]; then
+  # First try to load from a user install
+  source "$HOME/.rvm/scripts/rvm"
+elif [[ -s "/usr/local/rvm/scripts/rvm" ]]; then
+  # Then try to load from a root install
+  source "/usr/local/rvm/scripts/rvm"
+else
+  printf "ERROR: An RVM installation was not found.\n"
+  exit 1
+fi
+
+# deletes and recreates a gemset
+function clean_gemset() {
+  RUBY=$1; GEMSET=$2
+  # easier than checking and emptying/creating
+  rvm --force gemset delete ${RUBY}@${GEMSET}
+  rvm gemset create $GEMSET
+}
+
+# runs rake test, optionally cleaning the gemset
+function rake_test() {
+  RUBY=$1; GEMSET=$2; SUBTASK=$3
+  echo
+  echo "-----------Running tests for '${RUBY}@${GEMSET}'------------"
+  rvm $RUBY
+
+  if [ $CLEAN -eq 1 ]; then
+    clean_gemset $RUBY $GEMSET
+    rvm gemset use $GEMSET
+    bundle install
+  else
+    rvm gemset use $GEMSET
+  fi
+
+  # 'rvm $RUBY_VER rake' doesn't work with bundle install
+  rake test${SUBTASK}
+  if [ $? -ne 0 ]; then exit 1; fi
+}
+
+# Loop through all perms of rubies and rails
+cd test
+for RBV in $RUBY_VERSIONS; do
+  rake_test $RBV $PROJECT_GEMSET $RAKE_UNIT_TASK_MODIFIER
+
+  NEXT_DIR=$RAILS_DIR
+  for RV in $RAILS_VERSIONS; do
+    if [ "$NEXT_DIR" == "$RAILS_DIR" ]; then
+      NEXT_DIR=${NEXT_DIR}/${RV}
+    else
+      NEXT_DIR=../${RV}
+    fi
+    cd $NEXT_DIR
+
+    rake_test $RBV ${PROJECT_GEMSET}_${RV} $RAILS_RAKE_TASK_MODIFIER
+  done
+
+  cd ../..
+done

data/test/test_helper.rb

@@ -4,6 +4,7 @@ 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__))
@@ -11,6 +12,13 @@ $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"
+  MONGOID_CONFIG = "mongoid.yml"
+  LOGGER_CONFIG = "central_logger.yml"
+
   def log(msg)
     @central_logger.mongoize({"id" => 1}) do
       @central_logger.debug(msg)
@@ -23,6 +31,16 @@ class Test::Unit::TestCase
     end
   end
 
+  def setup_for_config(source, dest=source)
+    File.delete(File.join(CONFIG_DIR, DEFAULT_CONFIG))
+    FileUtils.cp(File.join(SAMPLE_CONFIG_DIR, source),  File.join(CONFIG_DIR, dest))
+    @central_logger.send(:configure)
+  end
+
+  def teardown_for_config(file)
+    File.delete(File.join(CONFIG_DIR, file))
+  end
+
   def log_metadata(options)
     @central_logger.mongoize({"id" => 1}) do
       @central_logger.add_metadata(options)
@@ -37,4 +55,17 @@ class Test::Unit::TestCase
     @con = @central_logger.mongo_connection
     @collection = @con[@central_logger.mongo_collection_name]
   end
+
+  def create_user
+    db_conf = @central_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
+    @central_logger.mongo_connection.remove_user(@user)
+  end
+
 end

data/test/unit/central_logger_test.rb

@@ -8,39 +8,99 @@ class CentralLogger::MongoLoggerTest < Test::Unit::TestCase
   EXCEPTION_MSG = "Foo"
 
   context "A CentralLogger::MongoLogger" do
-    context "during configuration in instantiation" 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
         CentralLogger::MongoLogger.any_instance.stubs(:internal_initialize).returns(nil)
         @central_logger = CentralLogger::MongoLogger.new
-        @central_logger.send(:configure)
       end
 
-      should "set the default host, port, and capsize if not configured" do
-        assert_equal 'localhost', @central_logger.db_configuration['host']
-        assert_equal 27017, @central_logger.db_configuration['port']
-        assert_equal CentralLogger::MongoLogger::DEFAULT_COLLECTION_SIZE, @central_logger.db_configuration['capsize']
+      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
 
-      should "set the mongo collection name depending on the Rails environment" do
-        assert_equal "#{Rails.env}_log", @central_logger.mongo_collection_name
+      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
 
-      context "upon connecting to an empty database" do
+      # 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
           @central_logger.send(:connect)
-          common_setup
-          @collection.drop
+          assert @central_logger.authenticated?
+        end
+
+        teardown do
+          # config will be deleted by outer teardown
+          remove_user
+        end
+      end
+
+      context "after configuration" do
+        setup do
+          @central_logger.send(:configure)
         end
 
-        should "expose a valid mongo connection" do
-          assert_instance_of Mongo::DB, @central_logger.mongo_connection
+        should "set the default host, port, and capsize if not configured" do
+          assert_equal 'localhost', @central_logger.db_configuration['host']
+          assert_equal 27017, @central_logger.db_configuration['port']
+          assert_equal CentralLogger::MongoLogger::DEFAULT_COLLECTION_SIZE, @central_logger.db_configuration['capsize']
         end
 
-        should "create a capped collection in the database with the configured size" do
-          @central_logger.send(:check_for_collection)
-          assert @con.collection_names.include?(@central_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"] < CentralLogger::MongoLogger::DEFAULT_COLLECTION_SIZE + 1.megabyte
+        should "set the mongo collection name depending on the Rails environment" do
+          assert_equal "#{Rails.env}_log", @central_logger.mongo_collection_name
+        end
+
+        should "use the database name in the config file" do
+          assert_equal "system_log", @central_logger.db_configuration['database']
+        end
+
+        context "upon connecting to an empty database" do
+          setup do
+            @central_logger.send(:connect)
+            common_setup
+            @collection.drop
+          end
+
+          should "expose a valid mongo connection" do
+            assert_instance_of Mongo::DB, @central_logger.mongo_connection
+          end
+
+          should "not authenticate" do
+            assert !@central_logger.authenticated?
+          end
+
+          should "create a capped collection in the database with the configured size" do
+            @central_logger.send(:check_for_collection)
+            assert @con.collection_names.include?(@central_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"] < CentralLogger::MongoLogger::DEFAULT_COLLECTION_SIZE + 1.megabyte
+          end
         end
       end
     end
@@ -112,6 +172,9 @@ class CentralLogger::MongoLoggerTest < Test::Unit::TestCase
         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
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Phil Burrows
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-03 00:00:00 -04:00
+date: 2010-11-30 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -175,11 +175,15 @@ files:
 - lib/central_logger/initializer.rb
 - lib/central_logger/initializer_mixin.rb
 - lib/central_logger/mongo_logger.rb
-- lib/railtie.rb
+- lib/central_logger/railtie.rb
 - test/active_record.rb
-- test/config/database.yml
+- test/config/samples/central_logger.yml
+- test/config/samples/database.yml
+- test/config/samples/database_with_auth.yml
+- test/config/samples/mongoid.yml
 - test/rails.rb
 - test/shoulda_macros/log_macros.rb
+- test/test.sh
 - test/test_helper.rb
 - test/unit/central_logger_test.rb
 has_rdoc: true