diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index df1493d8c..2f152acb8 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -47,6 +47,7 @@ All definitions files include a header with the author and editors, so at some p
 * [Breeze](http://www.breezejs.com/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Browser Harness](https://github.com/scriby/browser-harness) (by [Chris Scribner](https://github.com/scriby))
 * [bucks](https://github.com/CyberAgent/bucks.js) (by [Shunsuke Ohtani](https://github.com/zaneli))
+* [bunyan](https://github.com/trentm/node-bunyan) (by [Alex Mikhalev](https://github.com/amikhalev))
 * [CasperJS](http://casperjs.org) (by [Jed Mao](https://github.com/jedmao))
 * [CanvasJS](http://canvasjs.com) (by [Mark Overholt](https://github.com/mover5))
 * [Cheerio](https://github.com/MatthewMueller/cheerio) (by [Bret Little](https://github.com/blittle))
diff --git a/bunyan/bunyan-test.ts b/bunyan/bunyan-test.ts
new file mode 100644
index 000000000..7b7266e3c
--- /dev/null
+++ b/bunyan/bunyan-test.ts
@@ -0,0 +1,106 @@
+/// <reference path="bunyan.d.ts" />
+
+import bunyan = require('bunyan');
+
+var ringBufferOptions:bunyan.RingBufferOptions = {
+    limit: 100
+};
+var ringBuffer:bunyan.RingBuffer = new bunyan.RingBuffer(ringBufferOptions);
+ringBuffer.write("hello");
+ringBuffer.end();
+ringBuffer.destroy();
+ringBuffer.destroySoon();
+
+var level:number;
+level = bunyan.resolveLevel("trace");
+level = bunyan.resolveLevel("debug");
+level = bunyan.resolveLevel("info");
+level = bunyan.resolveLevel("warn");
+level = bunyan.resolveLevel("error");
+level = bunyan.resolveLevel("fatal");
+level = bunyan.resolveLevel(bunyan.TRACE);
+level = bunyan.resolveLevel(bunyan.DEBUG);
+level = bunyan.resolveLevel(bunyan.INFO);
+level = bunyan.resolveLevel(bunyan.WARN);
+level = bunyan.resolveLevel(bunyan.ERROR);
+level = bunyan.resolveLevel(bunyan.FATAL);
+
+var options:bunyan.LoggerOptions = {
+    name: 'test-logger',
+    streams: [{
+        type: 'stream',
+        stream: process.stdout,
+        level: bunyan.TRACE
+    }, {
+        type: 'file',
+        path: '/tmp/test.log',
+        level: bunyan.DEBUG,
+        closeOnExit: true
+    }, {
+        type: 'rotating-file',
+        path: '/tmp/test2.log',
+        level: bunyan.INFO,
+        closeOnExit: false
+    }, {
+        type: 'raw',
+        stream: process.stderr,
+        level: bunyan.WARN
+    }, {
+        type: 'raw',
+        stream: ringBuffer,
+        level: bunyan.ERROR
+    }]
+};
+
+var log = bunyan.createLogger(options);
+
+log.addSerializers(bunyan.stdSerializers);
+var child = log.child({name: 'child'});
+child.reopenFileStreams();
+log.addStream({path: '/dev/null', name: 'stream1'});
+child.level(bunyan.DEBUG);
+child.level('debug');
+child.levels(0, bunyan.ERROR);
+child.levels(0, 'error');
+child.levels('stream1', bunyan.FATAL);
+child.levels('stream1', 'fatal');
+
+var buffer = new Buffer(0);
+var error = new Error('');
+var object = {
+    test: 123
+};
+
+log.trace(buffer);
+log.trace(error);
+log.trace(object);
+log.trace('Hello, %s', 'world!');
+log.debug(buffer);
+log.debug(error);
+log.debug(object);
+log.debug('Hello, %s', 'world!');
+log.info(buffer);
+log.info(error);
+log.info(object);
+log.info('Hello, %s', 'world!');
+log.warn(buffer);
+log.warn(error);
+log.warn(object);
+log.warn('Hello, %s', 'world!');
+log.error(buffer);
+log.error(error);
+log.error(object);
+log.error('Hello, %s', 'world!');
+log.fatal(buffer);
+log.fatal(error);
+log.fatal(object);
+log.fatal('Hello, %s', 'world!');
+
+var recursive = {
+    hello: 'world',
+    whats: {
+        huh: recursive
+    }
+}
+
+JSON.stringify(recursive, bunyan.safeCycles());
diff --git a/bunyan/bunyan.d.ts b/bunyan/bunyan.d.ts
new file mode 100644
index 000000000..d26049bc3
--- /dev/null
+++ b/bunyan/bunyan.d.ts
@@ -0,0 +1,100 @@
+// Type definitions for node-bunyan
+// Project: https://github.com/trentm/node-bunyan
+// Definitions by: Alex Mikhalev <https://github.com/amikhalev>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "bunyan" {
+    import events = require('events');
+    import EventEmitter = events.EventEmitter;
+    import WritableStream = NodeJS.WritableStream;
+
+    class Logger extends EventEmitter {
+        constructor(options:LoggerOptions);
+        addStream(stream:Stream):void;
+        addSerializers(serializers:Serializers):void;
+        child(options:LoggerOptions, simple?:boolean):Logger;
+        reopenFileStreams():void;
+
+        level(value:any /* number | string */):void;
+        levels(name:any /* number | string */, value:any /* number | string */):void;
+
+        trace(error:Error, format?:any, ...params:any[]):void;
+        trace(buffer:Buffer, format?:any, ...params:any[]):void;
+        trace(obj:Object, format?:any, ...params:any[]):void;
+        trace(format:string, ...params:any[]):void;
+        debug(error:Error, format?:any, ...params:any[]):void;
+        debug(buffer:Buffer, format?:any, ...params:any[]):void;
+        debug(obj:Object, format?:any, ...params:any[]):void;
+        debug(format:string, ...params:any[]):void;
+        info(error:Error, format?:any, ...params:any[]):void;
+        info(buffer:Buffer, format?:any, ...params:any[]):void;
+        info(obj:Object, format?:any, ...params:any[]):void;
+        info(format:string, ...params:any[]):void;
+        warn(error:Error, format?:any, ...params:any[]):void;
+        warn(buffer:Buffer, format?:any, ...params:any[]):void;
+        warn(obj:Object, format?:any, ...params:any[]):void;
+        warn(format:string, ...params:any[]):void;
+        error(error:Error, format?:any, ...params:any[]):void;
+        error(buffer:Buffer, format?:any, ...params:any[]):void;
+        error(obj:Object, format?:any, ...params:any[]):void;
+        error(format:string, ...params:any[]):void;
+        fatal(error:Error, format?:any, ...params:any[]):void;
+        fatal(buffer:Buffer, format?:any, ...params:any[]):void;
+        fatal(obj:Object, format?:any, ...params:any[]):void;
+        fatal(format:string, ...params:any[]):void;
+    }
+
+    interface LoggerOptions {
+        name: string;
+        streams?: Stream[];
+        level?: string;
+        stream?: WritableStream;
+        serializers?: Serializers;
+        src?: boolean;
+    }
+
+    interface Serializers {
+        [key:string]: (input:any) => string;
+    }
+
+    interface Stream {
+        type?: string;
+        level?: any; // number | string
+        path?: string;
+        stream?: WritableStream;
+        closeOnExit?: boolean;
+    }
+
+    export var stdSerializers:Serializers;
+
+    export var TRACE:number;
+    export var DEBUG:number;
+    export var INFO:number;
+    export var WARN:number;
+    export var ERROR:number;
+    export var FATAL:number;
+
+    export function resolveLevel(value:any /* number | string */):number;
+
+    export function createLogger(options:LoggerOptions):Logger;
+
+    class RingBuffer extends EventEmitter {
+        constructor(options:RingBufferOptions);
+
+        writable:boolean;
+        records:any[];
+
+        write(record:any):void;
+        end(record?:any):void;
+        destroy():void;
+        destroySoon():void;
+    }
+
+    interface RingBufferOptions {
+        limit?: number;
+    }
+
+    export function safeCycles():(key:string, value:any) => any;
+}