MongoDB 2.6 cannot be installed as a Windows service

2014-04-25 by mookid8000 Leave a comment

I like applications that are distributed in ZIP files, because then it usually means that they don’t rely on the registry and all other kinds of nasty stuff that makes it hard to clean up afterwards.

But today, when I wanted to install the newest MongoDB 2.6 on a Windows server and I did the usual

mongod --install --logpath e:\logs\mongodb\log.txt --dbpath e:\data\mongodb

1	mongod --install --logpath e:\logs\mongodb\log.txt --dbpath e:\data\mongodb

in an elevated command prompt, nothing happened.

When I checked out the log file in e:\logs\mongodb\log.txt it said “–install has to be used with –logpath” – but I did specify the log path, I know you have to do that, and I always do that.

After trying this a few times, I thought: Well, until now I’ve done in-place upgrades of MongoDB whenever there was a new version, so why not just install 2.4 (which I know can be installed), and then replace the binaries with the 2.6 ones.

Which I did – and it worked!

wow-cool

So this is how you can install the current MongoDB version 2.6 as a Windows service, even though it seems to be a little off with its command line parameter checking.

PS: I just Googled to see if anyone else has experience this issue – it seems they already know about it + the workaround. Seems the 2.6 release was shipped a little too soon 😉 (PPS: We all do that sometimes…)

Online MongoDB courses

2013-03-12 by mookid8000 Leave a comment

mongo-db-huge-logo_0 This weekend, I completed the MongoDB (Python) developer and DBA courses, and I can really recommend them if you are interested in a gentle, yet fairly challenging, introduction to MongoDB.

The courses are run over ~7 weeks with instructional videos being released every week, and every week a couple of exercises must be completed in order to qualify for the final exam. Everything is online, and it’s completely free!

Next round begins on the 1st and 29th of April for the DEV and DBA courses respectively, and you can sign up at 10gen’s education site.

(PS: I got a 90% score on the DEV course and 96% on DBA – does that mean I’m more qualified to be a DBA than a developer..? I hope not!)

I’ll be speaking at Warm Crocodile Developer Conference

2012-11-28 by mookid8000 Leave a comment

In Copenhagen, on the 16th and 17th of January, there’s a new conference called Warm Crocodile – pretty cool title, if you ask me!

I begged and begged, until they caved in and gave me an hour of their otherwise extremely cool schedule – so I’ll be giving a talk that I’ve dubbed “Taking the hippie bus to the enterprise”… it will most likely be about using a free .NET service bus in combination with other cool free software to rapidly solve enterprisey problems without feeling a lot of pain.

If you’re interested, you can read the full abstract here: Taking the hippie bus to the enterprise

Slides from my MOW 2012 talks

2012-04-20 by mookid8000 Leave a comment

Yesterday, I did two talks at Miracle Open World: “So you want to liberate your data?” and “Ride the bus!”

Slides are available here:

So you want to liberate your data?

View more presentations from Mogens Heller Grabe

Ride The Bus!

View more presentations from Mogens Heller Grabe

I will be speaking at Miracle Open World 2012

2012-01-06 by mookid8000 Leave a comment

In April, I will be doing two presentations at Miracle’s Open World conference. It looks like a lot of cool people are going, and it’s my first time at MOW, so it goes without saying that I’m excited about it!

First, I’ll be doing a brand new intro to NServiceBus, which I have used extensively for the last two years. Even though I wish it was free for everyone to use, NServiceBus continues to be an awesome framework, so I’d like to continue spread the word about it – you can read my abstract here: Ride the Bus!.

After that, it seems I’ll be topping off day one with a brand new, condensed, platform-agnostic and pure MongoDB tour – this one will not do the usual “and this is NoSQL, and this is what characterizes a document DB”-intro, this will be full-on and to the point. You can read about it here: So you want to liberate your data?

I hope to see a lot of engaged people there 🙂

Frictionless Persistence in .NET with MongoDB is available on Channel 9

2011-06-24 by mookid8000 1 Comment

Microsoft were cool enough to record my talk at this year’s Goto Cph, even though the talk was on the Cloud and NoSQL track.

You can watch it here.

Afterwards, go check out all the other great presentations – it’s so cool they’ re made available!

Free geek night about MongoDB

2011-05-30 by mookid8000 Leave a comment

At Goto Copenhagen this May, I gave a talk about MongoDB, which is a nifty document-oriented database that I find pretty interesting.

So, because I like to talk about MongoDB so much, I’ll give my talk again as a free Trifork geek night on Tuesday the 21th of June at the Trifork HQ in Aarhus (this time in Danish though).

If you’re a .NET person, possibly developing big enterprisey stuff and/or you’re interested in MongoDB or NoSQL in general, you should come to this one.

Tinkering with MongoDB and sharding

2011-05-12 by mookid8000 5 Comments

After my MongoDB presentation today, I was asked a few questions about MongoDB’s sharding capabilities. Like my interest so far, my talk was completely focused on the frictionless aspects of using MongoDB, so I have never tried any of the sharding and replica set configurations that MongoDB can run in.

That has got to end!

So, let’s try spinning up the simplest possible sharding scenario that we can think of: Two durable MongoDB instances on port 27017 and 27018 with one collection sharded across them:

mkdir c:\data\db1
mongod --shardsvr --port 27017 --journal --dbpath c:\data\db1

1 2	mkdir c:\data\db1 mongod --shardsvr --port 27017 --journal --dbpath c:\data\db1

mkdir c:\data\db2
mongod --shardsvr --port 27018 --journal --dbpath c:\data\db2

1 2	mkdir c:\data\db2 mongod --shardsvr --port 27018 --journal --dbpath c:\data\db2

MongoDB sharding requires that you spin up a special configuration server that stores the configuration of which shards are available – let’s spin this up on port 27019:

mkdir c:\data\configdb
mongod --configsvr --port 27019 --dbpath c:\data\configdb

1 2	mkdir c:\data\configdb mongod --configsvr --port 27019 --dbpath c:\data\configdb

– and finally, we spin up one instance of mongos on port 27020, pointing it towards the configuration server:

mongos --configdb localhost:27019 --port 27020

1	mongos --configdb localhost:27019 --port 27020

To finalize the setup, we let the configuration database know of the two shards we have started by connecting to the admin database using the Mongo shell:

C:\mongodb\bin>mongo localhost:27020
MongoDB shell version: 1.8.1
connecting to: localhost:27020/test
> use admin
switched to db admin
> db.runCommand({addShard:"localhost:27017"})
> db.runCommand({addShard:"localhost:27018"})

C:\mongodb\bin>mongo localhost:27020

MongoDB shell version: 1.8.1

connecting to: localhost:27020/test

> use admin

switched to db admin

> db.runCommand({addShard:"localhost:27017"})

> db.runCommand({addShard:"localhost:27018"})

Now, let’s see if it understood this:

> db.runCommand({listShards: 1})
{
        "shards" : [
                {
                        "_id" : "shard0000",
                        "host" : "localhost:27017"
                },
                {
                        "_id" : "shard0001",
                        "host" : "localhost:27018"
                }
        ],
        "ok" : 1
}

> db.runCommand({listShards: 1})

{

"shards" : [

{

"_id" : "shard0000",

"host" : "localhost:27017"

{

"_id" : "shard0001",

"host" : "localhost:27018"

}

"ok" : 1

}

As you can see, the config database correctly stored information about our two shards – that was easy!

Finally, we need to enable sharding for one particular database and make sure that our collection of unicorns is sharded by the name field:

> db.runCommand({enableSharding: "fairytale"})
{ "ok" : 1 }
> db.runCommand({shardCollection: "fairytale.unicorns", key: {name: 1}})
{ "collectionsharded" : "fairytale.unicorns", "ok" : 1 }

> db.runCommand({enableSharding: "fairytale"})

{ "ok" : 1 }

> db.runCommand({shardCollection: "fairytale.unicorns", key: {name: 1}})

{ "collectionsharded" : "fairytale.unicorns", "ok" : 1 }

At this point, even though the fairytale database and unicorns collection did not exist, they have been created for me, and the required index has been created for the shard key. I can verify this like so:

> use fairytale
> db.unicorns.getIndexes()
[
        {
                "name" : "_id_",
                "ns" : "fairytale.unicorns",
                "key" : {
                        "_id" : 1
                },
                "v" : 0
        },
        {
                "ns" : "fairytale.unicorns",
                "key" : {
                        "name" : 1
                },
                "name" : "name_1",
                "v" : 0
        }
]

> use fairytale

> db.unicorns.getIndexes()

[

{

"name" : "_id_",

"ns" : "fairytale.unicorns",

"key" : {

"_id" : 1

"v" : 0

{

"ns" : "fairytale.unicorns",

"key" : {

"name" : 1

"name" : "name_1",

"v" : 0

}

]

Now, let’s go to C# with mongo-csharp and hammer 10 million randomly named unicorns, each carrying a payload of up to 8 KB of fairy dust in there:

class Program
{
    static readonly Random Random = new Random();

    static void Main()
    {
        var server = MongoServer.Create("mongodb://localhost:27020");
        var database = server.GetDatabase("fairytale");
        var unicorns = database.GetCollection("unicorns");

        using (database.RequestStart())
        {
            var batch = Enumerable.Range(0, 10000000)
                .Select(_ =>
                        new
                            {
                                name = GenerateRandomUnicornName(),
                                horns = 1,
                                likes = new[] {"eggs", "beer"},
                                fairy_dust = GenerateRandomBytes(Random.Next(8192))
                            });
                
            unicorns.InsertBatch(batch);

            server.GetLastError();
        }
            
        server.Disconnect();
    }

    static byte[] GenerateRandomBytes(int length)
    {
        var bytes = new byte[length];
        Random.NextBytes(bytes);
        return bytes;
    }

    static string GenerateRandomUnicornName()
    {
        Func<char> charFactory = () => (char)('a' + Random.Next(25));
        var funcs = Enumerable.Repeat(charFactory, 10 + Random.Next(30));
        return new string(funcs.Select(f => f()).ToArray());
    }
}

class Program

{

static readonly Random Random = new Random();

static void Main()

{

var server = MongoServer.Create("mongodb://localhost:27020");

var database = server.GetDatabase("fairytale");

var unicorns = database.GetCollection("unicorns");

using (database.RequestStart())

{

var batch = Enumerable.Range(0, 10000000)

.Select(_ =>

new

{

name = GenerateRandomUnicornName(),

horns = 1,

likes = new[] {"eggs", "beer"},

fairy_dust = GenerateRandomBytes(Random.Next(8192))

});

unicorns.InsertBatch(batch);

server.GetLastError();

}

server.Disconnect();

}

static byte[] GenerateRandomBytes(int length)

{

var bytes = new byte[length];

Random.NextBytes(bytes);

return bytes;

}

static string GenerateRandomUnicornName()

{

Func<char> charFactory = () => (char)('a' + Random.Next(25));

var funcs = Enumerable.Repeat(charFactory, 10 + Random.Next(30));

return new string(funcs.Select(f => f()).ToArray());

}

now, let’s go to the Mongo shell and see if they’re there:

> db.unicorns.count()
10000000

1 2	> db.unicorns.count() 10000000

Great! 10 million unicorns in there. Let’s check out the disk and see if data was somehow distributed among the shards:

That seems to be pretty well balanced if you ask me. Let’s see what Mongo can tell us:

> db.printShardingStatus()
--- Sharding Status ---
  sharding version: { "_id" : 1, "version" : 3 }
  shards:
      { "_id" : "shard0000", "host" : "localhost:27017" }
      { "_id" : "shard0001", "host" : "localhost:27018" }
  databases:
        { "_id" : "admin", "partitioned" : false, "primary" : "config" }
        { "_id" : "fairytale", "partitioned" : true, "primary" : "shard0000" }
                fairytale.unicorns chunks:
                                shard0001       66
                                shard0000       65
                        too many chunksn to print, use verbose if you want to force print

> db.printShardingStatus()

--- Sharding Status ---

sharding version: { "_id" : 1, "version" : 3 }

shards:

{ "_id" : "shard0000", "host" : "localhost:27017" }

{ "_id" : "shard0001", "host" : "localhost:27018" }

databases:

{ "_id" : "admin", "partitioned" : false, "primary" : "config" }

{ "_id" : "fairytale", "partitioned" : true, "primary" : "shard0000" }

fairytale.unicorns chunks:

shard0001 66

shard0000 65

too many chunksn to print, use verbose if you want to force print

66 chunks on the 1st shard, and 65 chunks on the 2nd shard – it is in fact pretty well balanced.

Conclusion so far

It seems to be pretty easy to begin sharding data, which is perfectly in line with the usual MongoDB feeling. It’s definitely a subject I need to look more into though, so if you want to read more about it, I can really recommend Kristina Chodorow‘s blog: Snail In A Turtleneck.

I’ll be speaking about MongoDB at GotoCph

2011-04-01 by mookid8000 Leave a comment

I started playing around with MongoDB about a year ago, and since then I have grown to like it so much that I am going to try to tell what I know at the first ever Goto Copenhagen.

The talk is scheduled on the “Cloud and NoSQL” track on Thursday at 14:05.

A link directly to the abstract can be found here.

(PS: This is not an April fool’s day prank… :))

Getting my Mongo on

2011-01-24 by mookid8000 11 Comments

This is the sixth post in a small series on Node.js. In this post, I will take a look at how to use my MongoDB from a Node app.

First, let’s install a driver for MongoDB: node-mongodb-native:

npm install mongodb

1	npm install mongodb

NPM really make it easy to get going!

Now, in order to connect to MongoDB, do this:

var mongo = require('mongodb');
var server = new mongo.Server(host_name, port_number, {auto_reconnect: true});
var db = new mongo.Db(database_name, server, {});

db.open(function(err) {
    // if you need to authenticate, do it here (otherwise just omit the following line):
    db.authenticate(username, password, function(err) {
        // now we're ready!
    });
});

var mongo = require('mongodb');

var server = new mongo.Server(host_name, port_number, {auto_reconnect: true});

var db = new mongo.Db(database_name, server, {});

db.open(function(err) {

// if you need to authenticate, do it here (otherwise just omit the following line):

db.authenticate(username, password, function(err) {

// now we're ready!

});

This should be done only once when the application starts up.

Then, to access a collection, do this:

db.collection(collection_name, function(err, coll) {
    // do stuff in here
});

db.collection(collection_name, function(err, coll) {

// do stuff in here

});

Inside the function above, coll gives you access to do all the usual stuff to a MongoDB collection. To name a few, there’s insert, find, findOne, ensureIndex, count, etc.

As the node-mongodb-native documentation is pretty sparse, I’ve found it useful to open up a Node.js shell and connect with the driver, allowing me to inspect the various objects’ properties and methods, e.g. by inspecting db.__proto__ like so:

mogens-heller-grabes-macbook-pro:~ mhg$ node
> var util = require('util');
> var mongo = require('mongodb');
> var server = new mongo.Server('localhost', 27017, {auto_reconnect:true});
> var db = new mongo.Db('test', server, {});
> db.open(function(err){});
> console.log(util.inspect(db.__proto__, true, 1));
{ logout: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  resetErrorHistory: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  ensureIndex: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },
  open: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  lastError: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  dropCollection: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  executeDbCommand: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  executeCommand: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  previousErrors: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  removeUser: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  collection: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  dropIndex: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  error: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  createCollection: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  command: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  indexInformation: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  [constructor]: 
   { [Function]
     [arguments]: null,
     [length]: 3,
     DEFAULT_URL: 'mongo://localhost:27017/default',
     super_: [Object],
     [name]: '',
     [prototype]: [Circular],
     [caller]: null },
  lastStatus: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  collections: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  addUser: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  cursorInfo: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  dereference: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  admin: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  createIndex: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },
  collectionsInfo: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  collectionNames: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  dropDatabase: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  authenticate: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  renameCollection: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  close: { [Function] [arguments]: null, [length]: 0, [name]: '', [prototype]: [Object], [caller]: null },
  eval: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null } }

mogens-heller-grabes-macbook-pro:~ mhg$ node

> var util = require('util');

> var mongo = require('mongodb');

> var server = new mongo.Server('localhost', 27017, {auto_reconnect:true});

> var db = new mongo.Db('test', server, {});

> db.open(function(err){});

> console.log(util.inspect(db.__proto__, true, 1));

{ logout: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

resetErrorHistory: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

ensureIndex: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },

open: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

lastError: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

dropCollection: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

executeDbCommand: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

executeCommand: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

previousErrors: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

removeUser: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

collection: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

dropIndex: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

error: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

createCollection: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

command: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

indexInformation: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

[constructor]:

{ [Function]

[arguments]: null,

[length]: 3,

DEFAULT_URL: 'mongo://localhost:27017/default',

super_: [Object],

[name]: '',

[prototype]: [Circular],

[caller]: null },

lastStatus: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

collections: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

addUser: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

cursorInfo: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

dereference: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

admin: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

createIndex: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },

collectionsInfo: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

collectionNames: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

dropDatabase: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

authenticate: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

renameCollection: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

close: { [Function] [arguments]: null, [length]: 0, [name]: '', [prototype]: [Object], [caller]: null },

eval: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null } }

and coll.__proto__ like so:

> db.collection('sessions', function(err, coll) { console.log(util.inspect(coll.__proto__, true, 1)); });
{ remove: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  rename: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  save: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  insert: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  group: { [Function] [arguments]: null, [length]: 6, [name]: '', [prototype]: [Object], [caller]: null },
  ensureIndex: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  drop: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  findOne: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  checkCollectionName: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  mapReduce: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },
  insertAll: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  createIndex: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  find: { [Function] [arguments]: null, [length]: 0, [name]: '', [prototype]: [Object], [caller]: null },
  count: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  options: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  indexInformation: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  dropIndex: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },
  distinct: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },
  normalizeHintField: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },
  update: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },
  [constructor]: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Circular], [caller]: null },
  findAndModify: { [Function] [arguments]: null, [length]: 6, [name]: '', [prototype]: [Object], [caller]: null },
  dropIndexes: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null } }

> db.collection('sessions', function(err, coll) { console.log(util.inspect(coll.__proto__, true, 1)); });

{ remove: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

rename: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

save: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

insert: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

group: { [Function] [arguments]: null, [length]: 6, [name]: '', [prototype]: [Object], [caller]: null },

ensureIndex: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

drop: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

findOne: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

checkCollectionName: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

mapReduce: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },

insertAll: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

createIndex: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

find: { [Function] [arguments]: null, [length]: 0, [name]: '', [prototype]: [Object], [caller]: null },

count: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

options: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

indexInformation: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

dropIndex: { [Function] [arguments]: null, [length]: 2, [name]: '', [prototype]: [Object], [caller]: null },

distinct: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Object], [caller]: null },

normalizeHintField: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null },

update: { [Function] [arguments]: null, [length]: 4, [name]: '', [prototype]: [Object], [caller]: null },

[constructor]: { [Function] [arguments]: null, [length]: 3, [name]: '', [prototype]: [Circular], [caller]: null },

findAndModify: { [Function] [arguments]: null, [length]: 6, [name]: '', [prototype]: [Object], [caller]: null },

dropIndexes: { [Function] [arguments]: null, [length]: 1, [name]: '', [prototype]: [Object], [caller]: null } }

Of course this way of barfing functions all over the place is not pretty, but it makes it possible to get a glimpse of what kinds of operations that can be performed on the various objects.