This is the 10gen-supported Ruby driver for MongoDB[].

Here’s a quick code sample. See the MongoDB Ruby Tutorial ( for much more.

  require 'rubygems'
  require 'mongo'
  include Mongo

  db   ='sample-db')
  coll = db.collection('test')

  3.times do |i|
    coll.insert({'a' => i+1})
  puts "There are #{coll.count()} records. Here they are:"
  coll.find().each { |doc| puts doc.inspect }


Ruby Versions

The driver works and is consistently tested on Ruby 1.8.6, 1.8.7, and 1.9.1.

Note that if you’re on 1.8.7, be sure that you’re using a patchlevel >= 249. There are some IO bugs in earlier versions.


The driver’s gems are hosted at[]. Make sure you’re using the latest version of rubygems:

  $ gem update --system

Then you can install the mongo gem as follows:

  $ gem install mongo

The driver also requires the BSON gem:

  $ gem install bson

And for a significant performance boost, you’ll want to install the C extensions:

  $ gem install bson_ext

From the GitHub source

The source code is available at You can either clone the git repository or download a tarball or zip file. Once you have the source, you can use it from wherever you downloaded it or you can install it as a gem from the source by typing

  $ rake gem:install

To install the C extensions from source, type this instead:

  $ rake gem:install_extensions

That’s all there is to it!


For extensive examples, see the MongoDB Ruby Tutorial (

Bundled with the driver are many examples, located in the "examples" subdirectory. Samples include using the driver and using the GridFS class GridStore. MongoDB must be running for these examples to work, of course.

Here’s how to start MongoDB and run the "simple.rb" example:

  $ cd path/to/mongo
  $ ./mongod run
  ... then in another window ...
  $ cd path/to/mongo-ruby-driver
  $ ruby examples/simple.rb

See also the test code, especially test/test_db_api.rb.


Note: The GridStore class has been deprecated. Use either the Grid or GridFileSystem classes to take advantage of GridFS.

The Ruby driver include two abstractions for storing large files: Grid and GridFileSystem. The Grid class is a Ruby implementation of MongoDB’s GridFS file storage specification. GridFileSystem is essentailly the same, but provides a more filesystem-like API and assumes that filenames are unique.

An instance of both classes represents an individual file store. See the API reference for details, and see examples/gridfs.rb for code that uses many of the Grid features (metadata, content type, seek, tell, etc).


  include Mongo

  # Get a database
  db ='app-db')

  # GridFileSystem. Store the text "Hello, world!" in the fs.
  fs ='filename', 'w') do |f|
    f.write "Hello, world!"

  # GridFileSystem. Output "Hello, world!"
  fs ='filename', 'r') do |f|

  # Write a file on disk to the Grid
  file ='image.jpg')
  grid =
  id   = grid.put(file)

  # Retrieve the file
  file = grid.get(id)

  # Get all the file's metata


Thread Safety

The driver is thread-safe.

Connection Pooling

As of 0.18, the driver implements connection pooling. By default, only one socket connection will be opened to MongoDB. However, if you’re running a multi-threaded application, you can specify a maximum pool size and a maximum timeout for waiting for old connections to be released to the pool.

To set up a pooled connection to a single MongoDB instance:

  @conn ="localhost", 27017, :pool_size => 5, :timeout => 5)

A pooled connection to a paired instance would look like this:

  @conn ={:left  => ["", 27017],
                    :right => ["", 27017]}, nil,
                    :pool_size => 20, :timeout => 5)

Though the pooling architecture will undoubtedly evolve, it currently owes much credit to the connection pooling implementations in ActiveRecord and PyMongo.

Using with Phusion Passenger

When passenger is in smart spawning mode you need to be sure that child processes forked by passenger will create a new connection to the database. activerecord-mongo-adapter handles this for you, so if you are using that you shouldn’t need to worry about it. Otherwise you’ll either need to use conservative spawning[] or handle reconnecting when passenger forks a new process:

  if defined?(PhusionPassenger)
    PhusionPassenger.on_event(:starting_worker_process) do |forked|
      if forked
        # Call db.connect_to_master to reconnect here

The above code should be put in _environment.rb_ or in an initialization script.

See this thread[] for more details on this issue.

String Encoding

The BSON ("Binary JSON") format used to communicate with Mongo requires that strings be UTF-8 (

Ruby 1.9 has built-in character encoding support. All strings sent to Mongo and received from Mongo are converted to UTF-8 when necessary, and strings read from Mongo will have their character encodings set to UTF-8.

When used with Ruby 1.8, the bytes in each string are written to and read from Mongo as-is. If the string is ASCII all is well, because ASCII is a subset of UTF-8. If the string is not ASCII, it may not be a well-formed UTF-8 string.

Primary Keys

The field _id is a primary key. It is treated specially by the database, and its use makes many operations more efficient. The value of an _id may be of any type. The database itself inserts an _id value if none is specified when a record is inserted.

Primary Key Factories

A primary key factory is a class you supply to a DB object that knows how to generate _id values. If you want to control _id values or even their types, using a PK factory lets you do so.

You can tell the Ruby Mongo driver how to create primary keys by passing in the :pk option to the Connection#db method.

  db ='dbname', :pk =>

A primary key factory object must respond to :create_pk, which should take a hash and return a hash which merges the original hash with any primary key fields the factory wishes to inject.

NOTE: if the object already has a primary key, the factory should not inject a new key; this means that the object may already exist in the database. The idea here is that whenever a record is inserted, the :pk object’s create_pk method will be called and the new hash returned will be inserted.

Here is a sample primary key factory, taken from the tests:

  class TestPKFactory
    def create_pk(row)
      row['_id'] ||=

Here’s a slightly more sophisticated one that handles both symbol and string keys. This is the PKFactory that comes with the MongoRecord code (an ActiveRecord-like framework for non-Rails apps) and the AR Mongo adapter code (for Rails):

  class PKFactory
    def create_pk(row)
      return row if row[:_id]
      row.delete(:_id)      # in case it exists but the value is nil
      row['_id'] ||=

A database’s PK factory object may be set either when a DB object is created or immediately after you obtain it, but only once. The only reason it is changeable at all is so that libraries such as MongoRecord that use this driver can set the PK factory after obtaining the database but before using it for the first time.

The DB Class

Primary Key factories

See the section on "Primary Keys" above.

Strict mode

Each database has an optional strict mode. If strict mode is on, then asking for a collection that does not exist will raise an error, as will asking to create a collection that already exists. Note that both these operations are completely harmless; strict mode is a programmer convenience only.

To turn on strict mode, either pass in :strict => true when obtaining a DB object or call the :strict= method:

  db ='dbname', :strict => true)
  # I'm feeling lax
  db.strict = false
  # No, I'm not!
  db.strict = true

The method DB#strict? returns the current value of that flag.


Random cursor fun facts:


If you have the source code, you can run the tests. There’s a separate rake task for testing with the bson_ext C extension enabled.

  $ rake test:c

Or, to test without the extension:

  $ rake test:ruby

These will run both unit and functional tests. To run these tests alone:

  $ rake test:unit
  $ rake test:functional

To run any individual rake tasks with the C extension enabled, just pass C_EXT=true to the task:

  $ rake test:unit C_EXT=true

If you want to test replica pairs, you can run the following tests individually:

  $ rake test:pair_count
  $ rake test:pair_insert
  $ rake test:pair_query

It’s also possible to test replica pairs with connection pooling:

  $ rake test:pooled_pair_insert

Shoulda and Mocha

Running the test suite requires shoulda and mocha. You can install them as follows:

  $ gem install shoulda
  $ gem install mocha

The tests assume that the Mongo database is running on the default port. You can override the default host (localhost) and port (Connection::DEFAULT_PORT) by using the environment variables MONGO_RUBY_DRIVER_HOST and MONGO_RUBY_DRIVER_PORT.


This documentation is available online at You can generate the documentation if you have the source by typing

  $ rake ydoc

Then open the file ydoc/index.html.

Release Notes





 Copyright 2008-2010 10gen Inc.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   See the License for the specific language governing permissions and
   limitations under the License.