+Cobalt is a simple logger multiplexer that works with a JSON based format.
+You can instantiate it with a set of loggers or add them later
+(see API reference below). When logging anything, Cobalt will attempt to
+generate an Object that conforms to the Cobalt Log Format Definition
+(if required) and passes it to every logger it has by calling their `log`
+method.
+
+Example of instantiating a cobalt logger:
+
+In node:
+```
+require('cobalt-log');
+```
+
+In the browser just require the files. Then:
+
+```
+this.logger = new Cobalt.Console({
+ from : "Breezi Client",
+ loggers : [ new Cobalt.Logger.JsConsole({
+ formatter : Cobalt.Formatter.Token,
+ formatterOpts : {
+ formatString : "{{_from}}: {{message}}",
+ ansiColor : true
+ }
+ })]
+});
+```
+
+This code will create an instance with a JsConsole logger that uses the
+Token formatter (See loggers and formatters below).
+
+Cobalt works in a browser or inside node, so feel free to use cobalt all
+over! (Also, see the socket logger below for info on connecting cobalt
+loggers)
+
+## Quick API Reference ##
+
+* **addLogger(logger)**: Adds a logger to the cobalt instance.
+* **removeLogger(logger)**: Removes a logger from the cobalt instance.
+* **buildLog(item, level=7)**: Generates a cobalt log object as if you had
+ logged item (it will do this automatically when you log anything)
+* **extendLog(object)**: Creates a dummy log object and extends it with
+ object.
+* **buildSeparator**: Generates a cobalt log object that defines a separator
+* **log, info, notice, warn, error**: Generates a log object with the
+ appropriate severity level and sends it to all loggers.
+* **separator()**: Generates a separator log object and sends it to all
+ loggers.
+* **space(lines)**: Logs an empty string `lines` times
+* **indent()**: Increases the indent level globally.
+* **indent(callback)**: Increases the indent level for anything logged
+ from inside the callback.
+* **outdent()/outdent(callback)**: Same as indent, but decreases indent level.
+* **color()**: Changes the color globally. †
+* **color(callback)**: Changes the color for anything logged from inside the
+ callback. †
+* **now()**: Returns the current time in microseconds, using performance.now()
+ or process.hrtime() if available. If not, falls back to miliseconds.
+
+† Cobalt doesn't really care about formatting or colors, but it allows you
+to set the `_color` property in the generated object. In the end, it's up to
+the formatter to decide if it will use this property. However, this maintains
+the old cobalt API and gives you flexibility in how you color your logs.
+
+
+## Loggers ##
+
+Cobalt doesn't depend on any particular logger, and the loggers it expects
+to receive is any object that responds to the log method. However, since it
+would pass a JSON object instead of a string, this may result in unexpected
+behavior for loggers that don't expect it. To ease the use of Cobalt with
+existing loggers, cobalt includes a couple of loggers that you can use out
+of the box.
+
+
+### Cobalt.Logger.JsConsole ###
+
+This logger communicates the Javascript console present in web browsers or
+node with cobalt. It uses the logLevel to trigger the appropriate method
+(e.g. info vs warn vs error). You can also initialize it with a formatter,
+to convert the log object to a string:
+
+```
+ new Cobalt.Logger.JsConsole({
+ formatter : Cobalt.Formatter.Token,
+ formatterOpts : {
+ formatString : "[{{_timestamp}}] {{message}} (@{{_from}})"
+ }
+ })
+```
+
+What this does is: it will trigger the method `format` on `formatter`
+passing the `logObject` and `formatterOpts`. This means that a formatter is
+any object that responds to `format(logObject, formatterOpts)`. It expects
+a string to be returned.
+
+### Cobalt.Logger.File ###
+
+This logger communicates a file via a writable stream, and is intended
+only for node. Like the JSConsole logger, you can also initialize it with
+a formatter to convert the log object to a string:
+
+```
+ new Cobalt.Logger.File({
+ formatter : Cobalt.Formatter.Token,
+ formatterOpts : {
+ formatString : "[{{_timestamp}}] {{message}} (@{{_from}})"
+ }
+ })
+```
+
+What this does is: it will trigger the method `format` on `formatter`
+passing the `logObject` and `formatterOpts`. This means that a formatter is
+any object that responds to `format(logObject, formatterOpts)`. It expects
+a string to be returned.
+
+### Cobalt.Logger.Socket ###
+
+This logger sends the log object to a socket using Socket.IO. It does not
+format the output. To catch the log from the recipient, you have to listen
+for the `log` event, and from there you can pass it to another Cobalt
+instance or do whatever you want with it.
+
+### More Loggers? ###
+
+You can build your own logger easily for any method of transport you find
+necessary (e.g. mail, database, twitter, etc). Any object that responds
+to `#log(logObject)` is a valid logger:
+
+```javascript
+// A valid, very minimalistic logger
+var simpleLogger = {
+ log : function (logObject) {
+ console.log(logObject.message);
+ }
+}
+
+logger.addLogger(simpleLogger);
+```
+
+## Formatters ##
+
+Cobalt itself makes no assumptions about the output of the logger and just
+passes the object to every logger it has. However, it is clear that loggers
+may want to manipulate this object. As shown in the JsConsole, a formatter
+should respond to the format method and receive a `logObject` and an
+`optsObject`. However, as this is not a core part of Cobalt, this is only a
+recommendation (as this is the way the included JsConsole/File loggers do it)
+and it is up to the logger on how to transform the object it receives.
+
+### Cobalt.Formatter.Simple ###
+
+This is the lazy formatter, it just outputs the string in the following
+format:
+
+```
+'[{{_timestamp}}][{{_logLevelString}}]{{_from}}: {{_message}}'
+```
+
+Where `_timestamp` is converted to ISO.
+
+Example output:
+
+```
+cobalt.log("hello world");
+// -> [2015-01-09T16:02:23.102Z][INFO] Generic Cobalt Logger : hello world
+```
+
+### Cobalt.Formatter.Token ###
+
+The Token formatter is a more advanced, but still fairly simple
+formatter. It takes a `formatString` and interpolates the properties
+of the object. By default it transforms anything inside double curly
+braces `{{likeThis}}`, however you can set a custom `replaceRule`.
+
+#### Accepted Options ####
+
+* `formatString` : The string used to replace. Defaults to `"{{message}}"`
+* `replaceRule` : The regex rule to use for replacement of tokens in the
+ formatString. Defaults to `/{{(.*?)}}/g`
+* `separatorLength` <Number> : How long to print separators. Defaults to 60.
+* `isoDate` <Boolean> : Whether or not to convert `_timestamp` to ISO
+ date. Defaults to true.
+* `separatorType` <String> : The string to use for the separator.
+ Defaults to `"="`
+* `ansiColor` <Boolean> : Whether to use ANSI colors for output.
+ Defaults to `false`. This options depends on `colors`
+
+#### Options ####
+
+* **formatString**: A string that defines the format of the output. It is a
+ string with double curly braces denoting fields. For example:
+ `"[{{_timestamp}}] {{message}} (@{{_from}})"` would attempt to extract the
+ \_timestamp, message and \_from fields to create a string similar to this:
+ `"[124896126491.123] Testing the logger (@Client Application)"`
+ (defaults to `"{{message}}"`)
+* **ansiColor**: A boolean value, when `true` will output the string in ANSI
+ color depending on the severity level (defaults to `false`)
+
+### More Formatters? ###
+
+As with loggers, cobalt itself does not worry about these things. However,
+if you wish to make a formatter that is exchangable with Token, you just
+need to create an object that responds to the`format(logObject, optionsObject)`
+method:
+
+```javascript
+// A valid, very minimalistic formatter
+var simpleFormatter = {
+ format : function (logObject, options) {
+ if (options.showDate) {
+ return "[" + Date(logObject._timeStamp) + "] " + logObject.message
+ } else {
+ return logObject.message;
+ }
+ }
+}
+
+logger.addLogger(new Cobalt.Logger.JsConsole({
+ formatter: simpleFormatter,
+ formatterOpts : {
+ showDate : true
+ }
+}));
+```
+
+## The Cobalt Log Format ##
+
+The Cobalt Log (CoLog) format is a JSON based log format used with cobalt.
+It is partly inspired in Greylog's GELF format, but with very notorious
+differences. The CoLog requires a header with certain fields that allow
+cobalt and its pieces to handle it. All header fields are prefixed with
+an underscore. Other than those fields, you can put whatever you want in
+the object; It's up to the loggers to make sense of the structure and
+display it in a way that makes sense.
+
+You can attempt to build this structure on your own, or let cobalt build it for
+you. Any object you pass for logging will be converted. However, if you
+build it on your own you have two options: The first one is use buildLog
+to create a log object for "item" as if you had logged "item" or you can
+use extendLog that will create a dummy log object and extends it with
+whatever object you pass to it.
+
+### Required Fields ###
+
+* **_version** : The version of cobalt this is designed to work with
+* **_timestamp** : A timestamp in microseconds.
+* **_cobaltLog** [true] : Cobalt will check for the \_cobaltLog to decide if
+transformation will happen or not.
+
+### Optional Fields ###
+
+* **\_from**: The sender of the log (Defaults to Generic Cobalt Logger)
+* **\_level**: The level of the log (Defaults to 7)
+* **\_levelString**: The string corresponding to the log level (e.g. 7 ->
+ DEBUG, 3 -> ERROR, 0 -> CRIT)
+* **\_indentLevel**: The indent level of the log
+* **\_color**: The color of the log
+* **\_separator**: If true, indicates that this is a separator and holds no
+ valuable information.
git.r.bdr.sh / rbdr / cologne / blobdiff