Add logstash transport support

Author: rodjjo

package-lock.json

@@ -24,6 +24,7 @@
   "dependencies": {
     "moment": "^2.24.0",
     "winston": "^3.2.1",
+    "winston-logstash-transport": "^2.0.0",
     "winston-sentry-raven-transport": "^1.0.2"
   },
   "devDependencies": {

package.json

@@ -1,9 +1,11 @@
 import * as winston from 'winston';
 import WinstonSentryRavenTransport from 'winston-sentry-raven-transport';
-import {loggerFactoryGenerator} from './logger-factory-generator';
+import { LogstashTransport } from 'winston-logstash-transport';
+import { loggerFactoryGenerator } from './logger-factory-generator';
 
 export const loggerFactory = loggerFactoryGenerator({
     winston,
     consoleTransportClass: winston.transports.Console,
     sentryTransportClass: WinstonSentryRavenTransport,
+    logstashTransportClass: LogstashTransport,
 });

src/index.ts

@@ -17,6 +17,13 @@ class FakeConsoleTransport extends TransportStream {
     }
 }
 
+let lastLogstashLog;
+class FakeLogstashTransport extends TransportStream {
+    log(info) {
+        lastLogstashLog = info;
+    }
+}
+
 let logger;
 const symbolMessage= Symbol.for('message');
 const symbolLevel= Symbol.for('level');
@@ -25,58 +32,95 @@ describe('gupy-logger', () => {
     beforeEach(()=>{
         lastConsoleLog = null;
         lastSentryLog = null;
+        lastLogstashLog = null;
+        const loggerFactory = loggerFactoryGenerator({
+            winston,
+            consoleTransportClass: FakeConsoleTransport,
+            sentryTransportClass: FakeSentryTransport,
+            logstashTransportClass: FakeLogstashTransport,
+        });
+        logger = loggerFactory({
+            config: {sentry: {enabled: true, dsn: 'any', level: 'info'},
+            logstash: {enabled: true, host: 'logstashhost', port: 12345, level: 'info'}}
+        });
+    });
+
+    it('should init without logstash by default', () => {
         const loggerFactory = loggerFactoryGenerator({
             winston,
             consoleTransportClass: FakeConsoleTransport,
-            sentryTransportClass: FakeSentryTransport
+            sentryTransportClass: FakeSentryTransport,
+            logstashTransportClass: undefined,
         });
+
         logger = loggerFactory({
-            config: {sentry: {enabled: true, dsn: 'any', level: 'info'}}
+            config: {sentry: {enabled: true, dsn: 'any', level: 'info'}},
         });
+
+        expect(logger).be.not.equal(undefined);
     });
 
     it('should log debug nowhere', () => {
         logger.debug('any info');
         expect(lastSentryLog).to.equal(null);
         expect(lastConsoleLog).to.deep.equal(null);
         expect(lastSentryLog).to.deep.equal(null);
+        expect(lastLogstashLog).to.deep.equal(null);
     });
 
-    it('should log info only at console', () => {
-        logger.info('any info');
-        expect(lastSentryLog).to.equal(null);
-        expect(lastConsoleLog).to.deep.equal({
+    it('should log info only at console and logstash', () => {
+        const expectedLog = {
             level: 'info',
             message: 'any info'
-        });
+        };
+
+        logger.info('any info');
+
+        expect(lastSentryLog).to.equal(null);
+        expect(lastConsoleLog).to.deep.equal(expectedLog);
+        expect(lastLogstashLog.application).to.equal('gupy');
+        expect(lastLogstashLog.message).to.equal('any info');
+        expect(lastLogstashLog.level).to.equal('info');
+
         expect(lastConsoleLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[info]: any info/);
         expect(lastConsoleLog[symbolLevel]).to.equal('info');
     });
 
-    it('should log warn only at console', () => {
-        logger.warn('any warn');
-        expect(lastSentryLog).to.equal(null);
-        expect(lastConsoleLog).to.deep.equal({
+    it('should log warn only at console and logstash', () => {
+        const expectedLog = {
             level: 'warn',
             message: 'any warn'
-        });
+        };
+
+        logger.warn('any warn');
+
+        expect(lastSentryLog).to.equal(null);
+        expect(lastConsoleLog).to.deep.equal(expectedLog);
+        expect(lastLogstashLog.application).to.equal('gupy');
+        expect(lastLogstashLog.message).to.equal('any warn');
+        expect(lastLogstashLog.level).to.equal('warn');
+
         expect(lastConsoleLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[warn]: any warn/);
         expect(lastConsoleLog[symbolLevel]).to.equal('warn');
     });
 
-    it('should log error at sentry and console', () => {
-        logger.error('any error');
-        expect(lastSentryLog).to.deep.equal({
+    it('should log error at all transport classes', () => {
+        const expectedLog = {
             level: 'error',
             message: 'any error'
-        });
+        };
+
+        logger.error('any error');
+
+        expect(lastLogstashLog.application).to.equal('gupy');
+        expect(lastLogstashLog.level).to.equal('error');
+        expect(lastLogstashLog.message).to.equal('any error');
+
+        expect(lastSentryLog).to.deep.equal(expectedLog);
         expect(lastSentryLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[error]: any error/);
         expect(lastSentryLog[symbolLevel]).to.equal('error');
 
-        expect(lastConsoleLog).to.be.deep.equal({
-            level: 'error',
-            message: 'any error'
-        });
+        expect(lastConsoleLog).to.be.deep.equal(expectedLog);
         expect(lastConsoleLog[symbolMessage]).to.match(/\d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{2}:\d{2} \[error]: any error/);
         expect(lastConsoleLog[symbolLevel]).to.equal('error');
     });

src/logger-factory-generator.test.ts

@@ -7,6 +7,13 @@ declare interface IConfig {
         dsn?: string,
         level?: string,
     };
+    logstash?: {
+        enabled?: boolean,
+        application?: string,
+        host?: string,
+        port?: number,
+        level?: string,
+    };
 }
 
 function prepareErrorToLog(error, messages = []) {
@@ -22,7 +29,7 @@ export interface IFactoryInterface {
 
 type LoggerFactoryType = ({config}: IFactoryInterface) => Logger;
 
-export const loggerFactoryGenerator = ({winston, consoleTransportClass, sentryTransportClass}): LoggerFactoryType => {
+export const loggerFactoryGenerator = ({winston, consoleTransportClass, sentryTransportClass, logstashTransportClass}): LoggerFactoryType => {
     return ({config}: IFactoryInterface) => {
         const transports = [];
         transports.push(new consoleTransportClass({
@@ -35,6 +42,28 @@ export const loggerFactoryGenerator = ({winston, consoleTransportClass, sentryTr
                 level: 'error',
             }));
         }
+
+        if (config.logstash && config.logstash.enabled && logstashTransportClass) {
+            const appendMetaInfo = winston.format((info) => {
+                return Object.assign(info, {
+                  application: config.logstash.application || 'gupy',
+                  pid: process.pid,
+                  time: moment.utc().format('YYYY-MM-DD HH:mm Z'),
+                });
+            });
+
+            transports.push(new logstashTransportClass({
+                host: config.logstash.host,
+                port: config.logstash.port,
+                level: config.logstash.level,
+                format: winston.format.combine(
+                    appendMetaInfo(),
+                    winston.format.json(),
+                    winston.format.timestamp()
+                ),
+            }));
+        }
+
         const logger: Logger = winston.createLogger({
             format: winston.format.printf(
                 error => `${moment.utc().format('YYYY-MM-DD HH:mm Z')} [${error.level}]: ${error.message}`,