Loglog Server

> Reads data from a loglog-source and displays in dev tools

__Install:__

``
npm install loglog-server
`

__Usage:__

You need to setup your own loglog server to execute with node. The loglog-server module simply exposes an express app.

`javascript
var server = require('loglog-server');
var auth = require('http-auth');

// It's necessary to have your datasource set before any requests
// are fulfilled
server.set( 'source', server.sources.mongodb({
// This configuration should be the same configuration for your
// loglog-mongodb logging transport
connection: 'mongodb://host:port/db'
, collection: 'collection_that_stores_logs'
}));

// Need to set url to inform socket.io what to connect to
server.set( 'url', 'https://myhost.com' );

// Custom authentication?
server.set( 'auth', auth.connect( auth.basic({
realm: "Simon Area.",
file: __dirname + "/../.htpasswd"
})));

// Listen on port 80
server.listen();
`

__Routes:__

`
GET / - Real-time log entries
GET /entries?q= - Search entries
`

REPL API

The primary way to use loglog-server is through the dev-tools REPL. Here are the functions available:

#### `pauseRealtime()`

Pauses the real-time logging

#### `resumeRealtime()`

Resumes real-time logging

#### `query( queryObj )`

Serializes the query object to the loglog-server data source and displays the results in the console.

_Returns the URL of the resource_

__MongoDB Example:__

`javascript
// Display all entries with request id = 123 sort by timestamp desc
query({ where: { 'data.req.id': 123 }, sort: { timestamp: -1 } })
`

#### `getUrl( [queryObj] )`

Returns the URL for a given query object. If no query object is returned, uses the last queryObj passed to query().

Loglog Server Data Sources

A loglog server uses data sources to get logging data from your applications. A source is a factory with the following signature: function ( Object options ) -> Object

The the return object must implement the following methods:

`javascript
{
check: function( callback ){ ... } // callback( error, results )
, query: function( query, callback ){ ... } // callback( error, results )
}
`

The check function is called periodically and should return the only latest log events from the source. So if a previous call to check returned events [1,2,3], then the next call should return those results.

The query function is called when the user is requesting a specific subset of the log history (and likely from within the check function). It's up to the data source as to what format the first parameter takes.

Here's what the mongodb source looks like:

`javascript
var MongoClient = require('mongodb').MongoClient;

module.exports = function( options ){
return {
check: function( callback ){
var query = {
where: this.lastResults.length
? { _id: { $gt: this.lastResults[0]._id } }
: {}
, options: {
sort: [ [ '_id', -1 ] ]
, limit: 20
}
};

this.query( query, function( error, results ){
if ( error ) return callback( error );
this.lastResults = results;
return callback( null, results );
}.bind( this ) );
}

, lastResults: []

, query: function( query, callback ){
query.where = query.where || {};
query.options = query.options || {};

MongoClient.connect( options.connection, function( error, db ){
if ( error ) return callback( error );

var cursor = db.collection(
options.collection
).find( query.where );

// Options
[
'sort', 'skip', 'limit'
].forEach( function( option ){
if ( option in query.options ){
cursor option ;
}
});

cursor.toArray( function( error, results ){
db.close();
callback( error, results );
});
});
}
};
};
``