feat: adding elastic search transport to project

src/__dependencies__/logger/index.ts

@@ -1,3 +1,23 @@
+import { ElasticSearchLogger } from './transports/elasticsearch/logger';
+import Env from '../../config/Env';
+import { ILogger } from '../../util/logger/ILogger';
 import PinoLogger from './pino';
 
-export default PinoLogger.getInstance();
+const loggerOptions = Env.app.logger.options;
+
+const loggers: ILogger[] = [];
+
+const validLoggers = {
+  ['elasticsearch'.toString()]: ElasticSearchLogger.getInstance(),
+  ['console'.toString()]: PinoLogger.getInstance(),
+};
+
+const validLoggersKeys = Object.keys(validLoggers);
+
+loggerOptions.forEach((logger: string) => {
+  if (validLoggersKeys.includes(logger)) {
+    loggers.push(validLoggers[logger]);
+  }
+});
+
+export default loggers;

src/__dependencies__/logger/pino/index.ts

@@ -1,16 +1,13 @@
 import { ILogger, ILoggerParams } from '../../../util/logger/ILogger';
 
-import Env from '../../../config/Env';
 import pino from 'pino';
 
 export default class PinoLogger implements ILogger {
   private static pinoLogger: PinoLogger;
   private pino;
 
   private constructor() {
-    this.pino = pino({
-      enabled: Env.app.logger.enabled,
-    });
+    this.pino = pino();
   }
 
   public static getInstance(): PinoLogger {

src/__dependencies__/logger/transports/elasticsearch/client.ts

@@ -0,0 +1,30 @@
+import elasticsearch, { Client } from 'elasticsearch';
+
+import Env from '../../../../config/Env';
+
+const elasticSearchEnv = Env.app.logger.elasticSearch;
+
+export interface ITransportParams {
+  readonly index: string;
+  readonly type: string;
+  readonly body: { timestamp: string; [key: string]: unknown };
+}
+
+export default class ElasticSearchService {
+  private static client: Client;
+
+  public static async getClient(): Promise<Client> {
+    this.client = this.client
+      ? this.client
+      : new elasticsearch.Client({
+          host: `${elasticSearchEnv.url}:${elasticSearchEnv.port}`,
+          apiVersion: elasticSearchEnv.version,
+        });
+    return this.client;
+  }
+
+  public static async log(params: ITransportParams): Promise<void> {
+    const client = await this.getClient();
+    await client.index(params);
+  }
+}

src/__dependencies__/logger/transports/elasticsearch/logger.ts

@@ -0,0 +1,32 @@
+import { ILogger, ILoggerParams } from '../../../../util/logger/ILogger';
+
+import ElasticSearchService from './client';
+
+export class ElasticSearchLogger implements ILogger {
+  private static elasticSearchLogger: ElasticSearchLogger;
+
+  private logToElastic(type: string, body: { [key: string]: unknown }) {
+    ElasticSearchService.log({
+      index: 'api',
+      type,
+      body: { ...body, timestamp: new Date().toString() },
+    });
+  }
+
+  info(message: ILoggerParams): void {
+    this.logToElastic('info', message);
+  }
+  warning(message: ILoggerParams): void {
+    this.logToElastic('warning', message);
+  }
+  error(message: ILoggerParams): void {
+    this.logToElastic('error', message);
+  }
+
+  public static getInstance(): ElasticSearchLogger {
+    this.elasticSearchLogger = this.elasticSearchLogger
+      ? this.elasticSearchLogger
+      : new ElasticSearchLogger();
+    return this.elasticSearchLogger;
+  }
+}

src/config/Env.ts

@@ -1,6 +1,13 @@
 interface IAppEnv {
   port: number;
-  logger: { enabled: boolean };
+  logger: {
+    options: string[];
+    elasticSearch: {
+      url: string;
+      port: number;
+      version: string;
+    };
+  };
   database: {
     address: string;
     username: string;
@@ -31,7 +38,12 @@ class Envs {
     return {
       port: Number(process.env.APP_PORT) || 3333,
       logger: {
-        enabled: Boolean(process.env.LOGGER_ENABLED) || false,
+        options: (process.env.LOGGER_OPTIONS || '').split(','),
+        elasticSearch: {
+          url: process.env.ELASTIC_SEARCH_URL || 'localhost',
+          port: Number(process.env.ELASTIC_SEARCH_PORT) || 9200,
+          version: process.env.ELASTIC_SEARCH_API_VERSION || '7.x',
+        },
       },
       database: {
         address: process.env.DATABASE_ADDRESS || 'localhost',

src/util/logger/Logger.ts

@@ -0,0 +1,38 @@
+import { ILogger, ILoggerParams } from './ILogger';
+
+export class Logger {
+  private loggers: ILogger[] = [];
+
+  public constructor(...loggers: ILogger[]) {
+    this.addLogger(...loggers);
+  }
+
+  public addLogger(...loggers: ILogger[]): void {
+    this.loggers.push(...loggers);
+  }
+
+  public removeLogger(logger: ILogger): void {
+    const loggerIndex = this.loggers.indexOf(logger);
+    if (loggerIndex !== -1) {
+      this.loggers.splice(loggerIndex);
+    }
+  }
+
+  public info(message: ILoggerParams): void {
+    this.loggers.forEach((logger) => {
+      logger.info(message);
+    });
+  }
+
+  public warning(message: ILoggerParams): void {
+    this.loggers.forEach((logger) => {
+      logger.warning(message);
+    });
+  }
+
+  public error(message: ILoggerParams): void {
+    this.loggers.forEach((logger) => {
+      logger.error(message);
+    });
+  }
+}

src/util/logger/index.ts

@@ -1,2 +1,3 @@
-import Logger from '../../__dependencies__/logger';
-export default Logger;
+import { Logger } from './Logger';
+import loggers from '../../__dependencies__/logger';
+export default new Logger(...loggers);