mongo_request_logger 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3e669f125a4ab156ae47726a5d04a0b98ecc3e2
-  data.tar.gz: e6e21f9084d3218669afabc377a92df36b833f8e
+  metadata.gz: 77639396cad58e5a076a1bfb8faf2814140c79a3
+  data.tar.gz: 04ef4b8af39a09990dd78a6d88648cae5f881902
 SHA512:
-  metadata.gz: 071197c22bff68a10b98732ca5dba433b8675551fda0e83cf7a2fd46a1d4bab538ec53fca8dae3404e3f3d16041631183a2bc2a98b7bca8623c46bf257ce3978
-  data.tar.gz: 8834d88af24fd96b4e760f763a8c449a85e1a80e6e26ae58044e6f4a7c653b9b2bc3e19ab67bdd52fa79d186e458e331ae4fe50f2df0837a2c038e6a3ab4b9b6
+  metadata.gz: 27db8433c868c7cf729afefb4418ca3dd90905c735e608cff97946c3f23098b7cd5ff158dcd77ce2dfa93a1c9a8d47f7f342d9ac60ec2ebca2a18fbe9ec58805
+  data.tar.gz: c60ac9125d39a8c98a43974f9ede24093904c90c3ec9a4c049114154d96c2d11ac3d3ced27f10af0f900648b41bb1c92394054196c2b10b6f521d34f8f435658

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.4.0
+
+*Backwards incompatible!*
+
+* Use Mongoid for managing sessions, with configuration in mongoid.yml instead of logger.yml.
+* Drop support for the moped driver.
+
 ## 0.3.1
 
 * Filter out passwords in parameters.

data/Gemfile

@@ -1,8 +1,7 @@
 source 'https://rubygems.org'
 
-gem 'mongo'
-gem 'bson_ext'
-gem 'moped'
+gem 'moped', '~> 1.5'
+gem 'mongoid', '~> 3.0'
 gem 'rspec'
 gem 'sinatra', '~> 1.4.0'
 

data/README.md

@@ -6,23 +6,28 @@ Log requests in a structured format to MongoDB.
 
 Add this line to your application's Gemfile:
 
+    gem 'mongoid', '~> 3.0'
     gem 'mongo_request_logger'
 
 ## Usage with Rails
 
-Create config/logger.yml containing something like the following:
+Add a `logger` session to your Mongoid config, `config/mongoid.yml`. An additional option
+`capsize` must be provided.
 
-    development:
-      host: localhost
-      database: your_app_logs_production_dev
-      capsize: 100  # megabytes
+Example:
 
-    production:
-      host: localhost
-      database: your_app_logs_production
-      username: your_app_logs_production
-      password: password
-      capsize: 1024 # megabytes
+    development:
+      sessions:
+        loggger:
+          database: your_log_db
+          hosts:
+            - host1:27017
+            - host2:27017
+            - host3:27017
+          options:
+            safe: false
+            consistency: eventual
+            capsize: 1000 # MB
 
 Routes for log viewer
 
@@ -39,7 +44,11 @@ In config.ru:
     require './yourapp'
 
     # Configure database details
-    MongoRequestLogger.configure(File.join(File.dirname(__FILE__), 'config/logger.yml'))
+    session = Moped::Session.new(%w(127.0.0.1:27017))
+    session.use 'your_log_db'
+    session.options[:capsize] = 10 # MB
+
+    MongoRequestLogger.configure(session: session)
 
     # Enable the middleware to log the requests
     use MongoRequestLogger::Rack

data/config.ru

@@ -2,9 +2,11 @@
 require 'moped'
 require 'mongo_request_logger/viewer'
 
-config = {database: ENV['DB'] || 'request_logger_test', collection: 'server_log', capsize: 10}
+session = Moped::Session.new(%w(127.0.0.1:27017))
+session.use ENV['DB'] || 'request_logger_test'
+session.options[:capsize] = 10 # MB
 
-MongoRequestLogger::Viewer.adapter = MongoRequestLogger::Adapters::Moped.new(config)
+MongoRequestLogger::Viewer.adapter = MongoRequestLogger::Adapters::Moped.new(session)
 
 MongoRequestLogger::Viewer.run!
 

data/gemfiles/sinatra1.3.gemfile

@@ -1,8 +1,7 @@
 source 'https://rubygems.org'
 
-gem 'mongo'
-gem 'bson_ext'
-gem 'moped'
+gem 'moped', '~> 1.5'
+gem 'mongoid', '~> 3.0'
 gem 'rspec'
 gem 'rails', '~> 3.2.10'
 gem 'sinatra', '~> 1.3.2'

data/gemfiles/sinatra1.4.gemfile

@@ -1,8 +1,7 @@
 source 'https://rubygems.org'
 
-gem 'mongo'
-gem 'bson_ext'
-gem 'moped'
+gem 'moped', '~> 1.5'
+gem 'mongoid', '~> 3.0'
 gem 'rspec'
 gem 'sinatra', '~> 1.4.0'
 

data/lib/mongo_request_logger.rb

@@ -8,55 +8,40 @@ if defined?(Rails)
   require 'mongo_request_logger/railtie'
 end
 
+require 'mongoid'
+require 'moped'
 require 'mongo_request_logger/adapters/moped'
-require 'mongo_request_logger/adapters/mongo'
 
 
 module MongoRequestLogger
-  def self.configure(config_path, options={})
-    require 'mongo_request_logger/config'
+
+  def self.session
+    @session
+  end
+
+  def self.configure(options={})
     require 'mongo_request_logger/rack'
     require 'mongo_request_logger/viewer'
 
-    begin
-      # We prefer moped ...
-      require 'moped'
-    rescue LoadError
-      # ... but fallback to mongo
-      require 'mongo'
-    end
-
     environment = ENV['RACK_ENV'] || ENV['RAILS_ENV']
+    session = options[:session] || Mongoid::Sessions.with_name(:logger)
+    if session
+      log_config = session.options
 
-    global_config = MongoRequestLogger::Config.new
-    global_config.load_file(config_path)
-    log_config = global_config.namespaced(environment)
-    fallback_log = options[:fallback_log] || log_config['fallback_log'] || "log/#{environment}.log"
+      fallback_log = options[:fallback_log] || log_config['fallback_log'] || "log/#{environment}.log"
 
+      adapter = MongoRequestLogger::Adapters::Moped.new(session)
 
-    if log_config && log_config['database']
-      if defined? Moped
-        adapter = MongoRequestLogger::Adapters::Moped.new(log_config)
-      else
-        adapter = MongoRequestLogger::Adapters::Mongo.new(log_config)
-      end
+      @session = session
 
       MongoRequestLogger::Viewer.adapter = adapter
 
-      if defined?(PhusionPassenger)
-        PhusionPassenger.on_event(:starting_worker_process) do |forked|
-          if forked
-            adapter.reconnect
-          end
-        end
-      end
-
       logger = MongoRequestLogger::Logger.new adapter, fallback_log
     else
+      fallback_log = options[:fallback_log] || "log/#{environment}.log"
       logger = ::Logger.new(fallback_log)
     end
 
-
     MongoRequestLogger::Rack.logger = logger
     MongoRequestLogger::Rack.ignore_prefixes << '/assets'
     MongoRequestLogger::Rack.ignore_prefixes << '/favicon.ico'

data/lib/mongo_request_logger/adapters/base.rb

@@ -7,7 +7,12 @@ module MongoRequestLogger
       attr_reader :configuration, :connection, :connection_type, :collection, :authenticated
 
       def collection_name
-        @configuration.collection
+        options[:collection] || 'server_log'
+      end
+
+      # Capsize in bytes
+      def capsize
+        options[:capsize] * 1024 * 1024
       end
 
       def authenticated?
@@ -37,7 +42,6 @@ module MongoRequestLogger
             :count => stats["count"].to_i,
             :size => stats["size"].to_f,
             :storageSize => stats["storageSize"].to_f,
-            :db_name => @configuration["database"],
             :collection => collection_name
         }
       end

data/lib/mongo_request_logger/adapters/moped.rb

@@ -1,8 +1,6 @@
 # Adapted from https://github.com/le0pard/mongodb_logger/
 
 require 'mongo_request_logger/adapters/base'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'mongo_request_logger/config'
 
 module MongoRequestLogger
   module Adapters
@@ -12,13 +10,8 @@ module MongoRequestLogger
       end
 
 
-      def initialize(options = {})
-        options = MongoRequestLogger::Config.new(options) unless options.is_a? MongoRequestLogger::Config
-        @configuration = options
-        @connection = ::Moped::Session.new(*options.moped_arguments)
-
-        login
-
+      def initialize(session)
+        @connection = session
         MongoRequestLogger::Adapters::Moped.connection = @connection
 
         @connection_type = @connection.class
@@ -26,23 +19,13 @@ module MongoRequestLogger
         check_for_collection
       end
 
-      def login
-        if @configuration.credentials
-          @authenticated = @connection.login(*@configuration.credentials)
-        end
-
-        # Allow MongoDB configured both with and without authentication
-        begin
-          @connection.command(ping: 1)
-        rescue ::Moped::Errors::AuthenticationFailure => e
-          @connection.logout
-          @connection.command(ping: 1)
-        end
+      def options
+        @connection.options
       end
 
       def create_collection
         @connection.cluster.with_primary do |node|
-          node.command(@configuration.database, {create: collection_name, capped: true, size:  @configuration.capsize})
+          node.command(@connection.send(:current_database).name, {create: collection_name, capped: true, size:  capsize})
         end
       end
 
@@ -74,28 +57,6 @@ module MongoRequestLogger
       def clear!
         @collection.drop
       end
-
-
     end
   end
 end
-
-# Adapted from Mongoid 3.0.16 lib/mongoid/railtie.rb
-
-# Unicorn clears the START_CTX when a worker is forked, so if we have
-# data in START_CTX then we know we're being preloaded. Unicorn does
-# not provide application-level hooks for executing code after the
-# process has forked, so we reconnect lazily.
-if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
-  MongoRequestLogger::Adapters::Moped.connection.disconnect if MongoRequestLogger::Adapters::Moped.connection
-end
-
-# Passenger provides the :starting_worker_process event for executing
-# code after it has forked, so we use that and reconnect immediately.
-if defined?(PhusionPassenger)
-  PhusionPassenger.on_event(:starting_worker_process) do |forked|
-    if MongoRequestLogger::Adapters::Moped.connection && forked
-      MongoRequestLogger::Adapters::Moped.connection.disconnect
-    end
-  end
-end

data/lib/mongo_request_logger/railtie.rb

@@ -7,7 +7,7 @@ if (defined? Rails) && Rails.version =~ /^3\./
     class Railtie < ::Rails::Railtie
       class << self
         def setup(app)
-          logger = MongoRequestLogger.configure(Rails.root.join('config/logger.yml'), fallback_log: Rails.root.join("log/#{Rails.env}.log"))
+          logger = MongoRequestLogger.configure(fallback_log: Rails.root.join("log/#{Rails.env}.log"))
 
           app.config.logger = logger
 
@@ -24,6 +24,24 @@ if (defined? Rails) && Rails.version =~ /^3\./
 
           app.config.middleware.insert_after ActionDispatch::DebugExceptions, MongoRequestLogger::Rack
 
+          app.config.after_initialize do
+            # Unicorn clears the START_CTX when a worker is forked, so if we have
+            # data in START_CTX then we know we're being preloaded. Unicorn does
+            # not provide application-level hooks for executing code after the
+            # process has forked, so we reconnect lazily.
+            if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
+              ::MongoRequestLogger.session.disconnect
+            end
+
+            # Passenger provides the :starting_worker_process event for executing
+            # code after it has forked, so we use that and reconnect immediately.
+            if ::Mongoid::Config.running_with_passenger?
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                ::MongoRequestLogger.session.disconnect if forked
+              end
+            end
+          end
+
         end
       end
 

data/lib/mongo_request_logger/version.rb

@@ -1,3 +1,3 @@
 module MongoRequestLogger
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/spec/moped_logger_spec.rb

@@ -16,16 +16,11 @@ describe 'MongoRequestLogger::Logger with moped' do
       session.logout
       session.command(ping: 1)
     end
-
+    
     session['server_log'].drop rescue nil
 
-
-    config = {
-        database: 'request_logger_test',
-        collection: 'server_log',
-        capsize: 10,
-    }
-    @adapter = MongoRequestLogger::Adapters::Moped.new(config)
+    session.options[:capsize] = 10
+    @adapter = MongoRequestLogger::Adapters::Moped.new(session)
 
     @file = 'test-log.txt'
     FileUtils.remove @file, :force => true
@@ -37,111 +32,4 @@ describe 'MongoRequestLogger::Logger with moped' do
 
   include_examples "log"
 
-  context "when configured with a simple config hash" do
-    it "should configure with a single host" do
-      config = {
-        host: 'localhost',
-        port: 27017,
-        database: 'request_logger_test',
-        collection: 'server_log',
-        capsize: 10,
-      }
-
-      adapter = MongoRequestLogger::Adapters::Moped.new(config)
-      connection = adapter.connection
-      connection.options[:database].should == 'request_logger_test'
-      connection.consistency.should == :eventual # The default
-      connection.cluster.nodes.first.resolved_address.should == '127.0.0.1:27017'
-    end
-
-    it "should configure with a host array" do
-      config = {
-        hosts: [
-          'localhost:27017',
-          'localhost:27017',
-          ],
-        database: 'request_logger_test',
-        collection: 'server_log',
-        capsize: 10,
-      }
-
-      adapter = MongoRequestLogger::Adapters::Moped.new(config)
-      connection = adapter.connection
-      connection.options[:database].should == 'request_logger_test'
-      connection.cluster.nodes[0].resolved_address.should == '127.0.0.1:27017'
-      connection.cluster.nodes[1].resolved_address.should == '127.0.0.1:27017'
-    end
-
-    it "should pass through options" do
-      # This should work similarly for ssl: true. Unfortunately, we don't have a
-      # ssl host to test against.
-      config = {
-          host: 'localhost',
-          port: 27017,
-          consistency: 'strong',
-          timeout: 30,
-          database: 'request_logger_test',
-          collection: 'server_log',
-          capsize: 10,
-      }
-
-      adapter = MongoRequestLogger::Adapters::Moped.new(config)
-      connection = adapter.connection
-      connection.options[:database].should == 'request_logger_test'
-      connection.options[:timeout].should == 30
-      connection.options[:consistency].should == :strong
-      connection.consistency.should == :strong
-
-      connection.cluster.nodes[0].resolved_address.should == '127.0.0.1:27017'
-    end
-  end
-
-  context "when configured with an URI" do
-    it "should configure with a single host" do
-      config = {
-          uri: 'mongodb://localhost:27017/request_logger_test',
-          collection: 'server_log',
-          capsize: 10,
-      }
-
-      adapter = MongoRequestLogger::Adapters::Moped.new(config)
-      connection = adapter.connection
-      connection.options[:database].should == 'request_logger_test'
-      connection.consistency.should == :eventual # The default
-      connection.cluster.nodes.first.resolved_address.should == '127.0.0.1:27017'
-    end
-
-    it "should configure with multiple hosts" do
-      # We only have a single real host to connect to, so we add it multiple times
-      config = {
-          uri: 'mongodb://localhost:27017,localhost:27017/request_logger_test',
-          collection: 'server_log',
-          capsize: 10,
-      }
-
-      adapter = MongoRequestLogger::Adapters::Moped.new(config)
-      connection = adapter.connection
-      connection.options[:database].should == 'request_logger_test'
-      connection.cluster.nodes[0].resolved_address.should == '127.0.0.1:27017'
-      connection.cluster.nodes[1].resolved_address.should == '127.0.0.1:27017'
-    end
-    
-    it "should configure with URI options" do
-      # This should work similarly for ssl=true. Unfortunately, we don't have a
-      # ssl host to test against.
-      config = {
-          uri: 'mongodb://localhost:27017/request_logger_test?consistency=strong',
-          collection: 'server_log',
-          capsize: 10,
-      }
-
-      adapter = MongoRequestLogger::Adapters::Moped.new(config)
-      connection = adapter.connection
-      connection.options[:database].should == 'request_logger_test'
-      connection.options[:consistency].should == :strong
-      connection.consistency.should == :strong
-
-      connection.cluster.nodes[0].resolved_address.should == '127.0.0.1:27017'
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongo_request_logger
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Embark Mobile
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-14 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -375,10 +375,8 @@ files:
 - gemfiles/sinatra1.4.gemfile
 - lib/mongo_request_logger.rb
 - lib/mongo_request_logger/adapters/base.rb
-- lib/mongo_request_logger/adapters/mongo.rb
 - lib/mongo_request_logger/adapters/moped.rb
 - lib/mongo_request_logger/backtrace_cleaner.rb
-- lib/mongo_request_logger/config.rb
 - lib/mongo_request_logger/ext/buffered_logger.rb
 - lib/mongo_request_logger/ext/logger.rb
 - lib/mongo_request_logger/log_message.rb
@@ -391,11 +389,9 @@ files:
 - lib/mongo_request_logger/version.rb
 - lib/mongo_request_logger/viewer.rb
 - mongo_request_logger.gemspec
-- spec/config_spec.rb
 - spec/dummy/application.rb
 - spec/dummy/config/logger.yml
 - spec/dummy/log/.gitkeep
-- spec/mongo_logger_spec.rb
 - spec/moped_logger_spec.rb
 - spec/query_spec.rb
 - spec/rails_spec.rb
@@ -431,11 +427,9 @@ signing_key:
 specification_version: 4
 summary: Structured logger and log viewer for Rack (including Rails) requests
 test_files:
-- spec/config_spec.rb
 - spec/dummy/application.rb
 - spec/dummy/config/logger.yml
 - spec/dummy/log/.gitkeep
-- spec/mongo_logger_spec.rb
 - spec/moped_logger_spec.rb
 - spec/query_spec.rb
 - spec/rails_spec.rb

data/lib/mongo_request_logger/adapters/mongo.rb

@@ -1,90 +0,0 @@
-# Adapted from https://github.com/le0pard/mongodb_logger/
-
-require 'mongo_request_logger/adapters/base'
-require 'mongo_request_logger/config'
-
-module MongoRequestLogger
-  module Adapters
-    class Mongo < Base
-
-      def initialize(options = {})
-        options = MongoRequestLogger::Config.new(options) unless options.is_a? MongoRequestLogger::Config
-        @configuration = options
-
-        mongo_connection_object
-        connect
-
-        check_for_collection
-      end
-
-      def connect
-        @connection ||= mongo_connection_object.db(@configuration.database)
-        if @configuration.credentials
-          @authenticated = @connection.authenticate(*@configuration.credentials)
-        end
-      end
-
-      def reconnect
-        connect
-      end
-
-      def create_collection
-        @connection.create_collection(collection_name,
-            {:capped => true, :size => @configuration['capsize'].to_i*1024*1024})
-      end
-
-      def create_index field
-        @collection.create_index(field)
-      end
-
-      def insert_log_record(record)
-        # TODO: we should make this non-safe?
-        @collection.insert(record)
-      end
-
-      def collection_stats
-        collection_stats_hash(@collection.stats)
-      end
-
-      def query(criteria, options={})
-        q = @collection.find(criteria).sort('timestamp', -1)
-        if options[:limit]
-          q = q.limit(options[:limit])
-        end
-        q
-      end
-
-      def find_by_id(id)
-        @collection.find_one(::BSON::ObjectId(id))
-      end
-
-      def clear!
-        raise NotImplementedError
-      end
-
-      private
-
-      def mongo_connection_object
-        hosts = @configuration.hosts
-        if @configuration['uri']
-          ::Mongo::Connection.from_uri(@configuration['uri'])
-        elsif hosts.count > 1
-          conn = ::Mongo::ReplSetConnection.new(*(hosts <<
-              {:connect => true, :pool_timeout => 6}))
-          @configuration['replica_set'] = true  # is this correct?
-        else
-          host = @configuration['host'] || '127.0.0.1'
-          port = @configuration['port'] || '27017'
-
-          conn = ::Mongo::Connection.new(host,
-              port,
-              :connect => true,
-              :pool_timeout => 6)
-        end
-        @connection_type = conn.class
-        conn
-      end
-
-    end
-  end
-end

data/lib/mongo_request_logger/config.rb

@@ -1,165 +0,0 @@
-require 'yaml'
-
-begin
-  require 'moped/mongo_uri'
-rescue LoadError
-  # Ignore
-end
-
-module MongoRequestLogger
-  class Config
-    attr_accessor :raw_config
-    attr_accessor :params
-    attr_accessor :namespace
-
-    def initialize(config=nil)
-      @params = {}
-      @namespace = nil
-      load_config(config.stringify_keys) unless config.nil?
-    end
-
-    def namespaced(namespace)
-      config = deep_merge(@params['common'], @params[namespace])
-      ac = self.class.new(config)
-      ac.namespace = namespace
-      ac
-    end
-
-
-    def namespaces
-      @params.keys - %w(common)
-    end
-
-    def load_file(file)
-      begin
-        hash = YAML::load(IO.read(file))
-      rescue => e
-        hash = nil
-      end
-      load_config(hash) unless hash.nil?
-    end
-
-    def deep_merge(a, b)
-      if a.is_a? Hash and b.is_a? Hash
-        r = a.stringify_keys
-        b = b.stringify_keys
-        for k, v in b
-          r[k] = deep_merge(a[k], v)
-        end
-        r
-      elsif b.is_a? Hash
-        b.stringify_keys
-      else
-        b
-      end
-    end
-
-    def load_config(config)
-      @params = deep_merge(@params, config)
-    end
-
-    def has?(param)
-      @params.key?(param.to_s)
-    end
-
-    def get(param)
-      @params[param.to_s]
-    end
-
-    def [](param)
-      get(param)
-    end
-
-    def []=(param, value)
-      @params[param.to_s] = value
-    end
-
-    def with_indifferent_access
-      self
-    end
-
-    def to_hash
-      @params.symbolize_keys
-    end
-
-    def hosts
-      if self['hosts']
-        return self['hosts']
-      elsif self.moped_uri
-        return self.moped_uri.hosts
-      else
-        host = self['host'] || '127.0.0.1'
-        port = self['port'] || 27017
-        return ["#{host}:#{port}"]
-      end
-    end
-
-    def credentials
-      if moped_uri && moped_uri.auth_provided?
-        [moped_uri.username, moped_uri.password]
-      elsif self['username'] && self['password']
-        [self['username'], self['password']]
-      else
-        nil
-      end
-    end
-
-    def database
-      if self['database']
-        self['database']
-      elsif moped_uri
-        moped_uri.database
-      else
-        nil
-      end
-    end
-
-    def collection
-      self['collection'] || 'server_log'
-    end
-
-    def capsize
-      self['capsize'].to_i*1024*1024
-    end
-
-    def moped_uri
-      if self['uri'] && defined? ::Moped::MongoUri
-        ::Moped::MongoUri.new(self['uri'])
-      else
-        nil
-      end
-    end
-
-    def moped_config
-      args = {}
-
-      if moped_uri
-        args = moped_uri.moped_arguments[1]
-      end
-
-      args[:database] = self.database
-
-      exclude = %w(host port hosts uri collection database capsize)
-
-      @params.each do |key, value|
-        next if exclude.include? key
-        args[key.to_sym] = cast(value)
-      end
-
-      args
-    end
-
-    def moped_arguments
-      [hosts, moped_config]
-    end
-
-    private
-    def cast(value)
-      if value.is_a? String
-        value.to_sym
-      else
-        value
-      end
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'mongo_request_logger/config'
-require 'mongo'
-
-include MongoRequestLogger
-
-describe MongoRequestLogger::Config do
-
-  it "should namespace" do
-    pending
-  end
-
-  it "should handle a simple case" do
-    config = MongoRequestLogger::Config.new({
-      host: 'example.org',
-      port: 1234,
-      database: 'request_logger_test',
-      collection: 'server_log',
-      capsize: 10,
-    })
-
-    config.hosts.should == ['example.org:1234']
-    config.moped_config.should == {database: 'request_logger_test'}
-  end
-
-  it "should default to localhost:27017" do
-    config = MongoRequestLogger::Config.new({
-      database: 'request_logger_test',
-      collection: 'server_log',
-      capsize: 10,
-    })
-
-    config.hosts.should == ['127.0.0.1:27017']
-    config.moped_config.should == {database: 'request_logger_test'}
-
-    config.database.should == 'request_logger_test'
-    config.collection.should == 'server_log'
-    config.capsize.should == 10485760
-  end
-
-  it "should configure with a host array" do
-    config = MongoRequestLogger::Config.new({
-      hosts: [
-        'node1.example.org:27017',
-        'node2.localhost:27017',
-        ],
-      database: 'request_logger_test',
-      collection: 'server_log',
-      capsize: 10,
-    })
-
-    config.hosts.should == [
-        'node1.example.org:27017',
-        'node2.localhost:27017',
-        ]
-    config.moped_config.should == {database: 'request_logger_test'}
-  end
-
-  it "should pass through options" do
-    # This should work similarly for ssl: true. Unfortunately, we don't have a
-    # ssl host to test against.
-    config = MongoRequestLogger::Config.new({
-      consistency: 'strong',
-      timeout: 30,
-      ssl: true,
-      database: 'request_logger_test',
-      collection: 'server_log',
-      capsize: 10,
-    })
-
-    config.moped_config.should == {
-      timeout: 30,
-      ssl: true,
-      consistency: :strong,
-      database: 'request_logger_test'
-    }
-  end
-
-  context "when configured with an URI" do
-    it "should configure with a single host" do
-      config = MongoRequestLogger::Config.new({
-        uri: 'mongodb://example.org:1234/request_logger_test',
-        collection: 'server_log',
-        capsize: 10
-      })
-
-      config.database.should == 'request_logger_test'
-      config.collection.should == 'server_log'
-      config.capsize.should == 10485760
-
-      config.hosts.should == ['example.org:1234']
-      config.moped_config.should == {database: 'request_logger_test'}
-    end
-
-    it "should configure with multiple hosts" do
-      # We only have a single real host to connect to, so we add it multiple times
-      config = MongoRequestLogger::Config.new({
-        uri: 'mongodb://node1.example.org:1234,node2.example.org:1234/request_logger_test',
-        collection: 'server_log',
-        capsize: 10
-      })
-
-      config.database.should == 'request_logger_test'
-      config.collection.should == 'server_log'
-
-      config.hosts.should == ['node1.example.org:1234', 'node2.example.org:1234']
-      config.moped_config.should == {database: 'request_logger_test'}
-    end
-    
-    it "should configure with URI options" do
-      config = MongoRequestLogger::Config.new({
-        uri: 'mongodb://example.org:1234/request_logger_test?consistency=strong&timeout=30&ssl=true',
-        collection: 'server_log',
-        capsize: 10
-      })
-
-      config.database.should == 'request_logger_test'
-      config.collection.should == 'server_log'
-
-      config.hosts.should == ['example.org:1234']
-      config.moped_config.should == {
-        consistency: :strong,
-        timeout: 30,
-        ssl: true,
-        database: 'request_logger_test'
-      }
-    end
-  end
-
-end

data/spec/mongo_logger_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'mongo_request_logger'
-require 'mongo'
-require 'shared_examples'
-require 'mongo_request_logger/adapters/mongo'
-
-include MongoRequestLogger
-
-describe 'MongoRequestLogger::Logger with mongo' do
-  before do
-    connection = Mongo::Connection.new
-    db = connection.db('request_logger_test')
-    db.authenticate('request_logger_test', 'test_password') rescue nil
-    db.drop_collection 'server_log' rescue nil
-
-    config = {
-        database: 'request_logger_test',
-        collection: 'server_log',
-        capsize: 10,
-    }
-
-    @adapter = MongoRequestLogger::Adapters::Mongo.new(config)
-
-    @file = 'test-log.txt'
-    FileUtils.remove @file, :force => true
-  end
-
-  after do
-    FileUtils.remove @file, :force => true
-  end
-
-  include_examples "log"
-end