@gus-eip/loggers 1.0.4 → 2.1.0

package/dist/cloudwatch.event.formatter.d.ts

@@ -0,0 +1,28 @@
+interface LogItem {
+    level: string;
+    message: string;
+    meta?: object;
+    date: Date;
+}
+interface FormatLogFunction {
+    (item: LogItem): string;
+}
+interface FormatLogItemFunction {
+    (item: LogItem): {
+        message: string;
+        timestamp: Date;
+    };
+}
+export declare class CloudWatchEventFormatter {
+    constructor({ formatLog, formatLogItem, }?: {
+        formatLog?: FormatLogFunction;
+        formatLogItem?: FormatLogItemFunction;
+    });
+    formatLogItem(item: LogItem): {
+        message: string;
+        timestamp: Date;
+    };
+    formatLog(item: LogItem): string;
+    isEmpty(value: any): boolean;
+}
+export {};

package/dist/cloudwatch.event.formatter.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudWatchEventFormatter = void 0;
+class CloudWatchEventFormatter {
+    constructor({ formatLog, formatLogItem, } = {}) {
+        if (typeof formatLog === 'function') {
+            this.formatLog = formatLog;
+        }
+        else if (typeof formatLogItem === 'function') {
+            this.formatLogItem = formatLogItem;
+        }
+    }
+    formatLogItem(item) {
+        return {
+            message: this.formatLog(item),
+            timestamp: item.date,
+        };
+    }
+    formatLog(item) {
+        const meta = this.isEmpty(item.meta)
+            ? ''
+            : ' ' + JSON.stringify(item.meta, null, 2);
+        return `${meta}`;
+    }
+    isEmpty(value) {
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            return Object.keys(value).length === 0;
+        }
+        else if (typeof value === 'string') {
+            return value.trim().length === 0;
+        }
+        else if (value instanceof Map || value instanceof Set) {
+            return value.size === 0;
+        }
+        return value === undefined || value === null;
+    }
+}
+exports.CloudWatchEventFormatter = CloudWatchEventFormatter;

package/dist/cloudwatch.logger.d.ts

@@ -1,12 +1,13 @@
 import { ILogger } from './interface';
 export declare class CloudWatchLoggerService implements ILogger {
-    private logger;
+    private readonly cloudwatch;
     private region;
     private logGroupName;
     constructor(region: string, logGroupName: string);
-    private defaultVersion;
-    private createCloudWatchTransport;
-    private logToCloudWatch;
+    private version;
+    createLogStream(logStreamName: string): Promise<any>;
+    logToCloudWatch(type: string, logObject: any, logStreamName: string): Promise<void>;
+    logStreamExists(logStreamName: string): Promise<boolean>;
     log(requestedId: string, message: any, event: string, statusCode: number, details: any, brand: any, logStreamName: string): Promise<any>;
     error(requestedId: string, message: any, event: string, errorCode: string, statusCode: number, details: any, brand: any, logStreamName: string): Promise<any>;
 }

package/dist/cloudwatch.logger.js

@@ -11,40 +11,68 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloudWatchLoggerService = void 0;
 const common_1 = require("@nestjs/common");
-const winston = require("winston");
-const CloudWatchTransport = require("winston-aws-cloudwatch");
-const AWS = require("aws-sdk");
+const aws_sdk_1 = require("aws-sdk");
+const cloudwatch_event_formatter_1 = require("./cloudwatch.event.formatter");
 let CloudWatchLoggerService = exports.CloudWatchLoggerService = class CloudWatchLoggerService {
     constructor(region, logGroupName) {
-        this.defaultVersion = 'v1';
+        this.version = 'v1';
+        this.cloudwatch = new aws_sdk_1.CloudWatchLogs({ region: region });
         this.region = region;
         this.logGroupName = logGroupName;
-        AWS.config.update({ region: this.region });
-        this.logger = winston.createLogger({
-            format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
-            transports: [new winston.transports.Console()],
-        });
     }
-    async createCloudWatchTransport(logStreamName) {
-        return new CloudWatchTransport({
+    async createLogStream(logStreamName) {
+        const createParams = {
             logGroupName: this.logGroupName,
-            logStreamName,
-            createLogGroup: true,
-            createLogStream: true,
-            level: 'info',
-        });
+            logStreamName: logStreamName,
+        };
+        await this.cloudwatch.createLogStream(createParams).promise();
     }
-    async logToCloudWatch(level, logObject) {
-        this.logger[level]('', {
+    async logToCloudWatch(type, logObject, logStreamName) {
+        if (!(await this.logStreamExists(logStreamName))) {
+            await this.createLogStream(logStreamName);
+        }
+        const formatter = new cloudwatch_event_formatter_1.CloudWatchEventFormatter();
+        logObject.version = this.version;
+        logObject.timestamp = new Date().toISOString();
+        const formattedLog = formatter.formatLogItem({
+            meta: logObject,
             ...logObject,
-            version: this.defaultVersion,
-            timestamp: new Date().toISOString(),
+            level: type,
+            date: new Date(),
         });
+        const timestampMillis = formattedLog.timestamp.getTime();
+        const putParams = {
+            logGroupName: this.logGroupName,
+            logStreamName: logStreamName,
+            logEvents: [{
+                    message: formattedLog.message,
+                    timestamp: timestampMillis
+                }],
+        };
+        try {
+            await this.cloudwatch.putLogEvents(putParams).promise();
+        }
+        catch (error) {
+            console.error('Error putting log events:', error);
+            throw error;
+        }
+    }
+    async logStreamExists(logStreamName) {
+        try {
+            const response = await this.cloudwatch
+                .describeLogStreams({
+                logGroupName: this.logGroupName,
+                logStreamNamePrefix: logStreamName,
+            })
+                .promise();
+            return response.logStreams && response.logStreams.length > 0;
+        }
+        catch (error) {
+            console.error('Error checking log stream:', error);
+            throw error;
+        }
     }
     async log(requestedId, message, event, statusCode, details, brand, logStreamName) {
-        console.log(this.region, this.logGroupName);
-        const transport = await this.createCloudWatchTransport(logStreamName);
-        await this.logger.add(transport);
         const logObject = {
             requestedId,
             message,
@@ -54,11 +82,9 @@ let CloudWatchLoggerService = exports.CloudWatchLoggerService = class CloudWatch
             details,
             brand,
         };
-        await this.logToCloudWatch('info', logObject);
+        await this.logToCloudWatch('info', logObject, logStreamName);
     }
     async error(requestedId, message, event, errorCode, statusCode, details, brand, logStreamName) {
-        const transport = await this.createCloudWatchTransport(logStreamName);
-        await this.logger.add(transport);
         const logObject = {
             requestedId,
             message,
@@ -69,7 +95,7 @@ let CloudWatchLoggerService = exports.CloudWatchLoggerService = class CloudWatch
             details,
             brand,
         };
-        await this.logToCloudWatch('error', logObject);
+        await this.logToCloudWatch('error', logObject, logStreamName);
     }
 };
 exports.CloudWatchLoggerService = CloudWatchLoggerService = __decorate([

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './cloudwatch.logger';
 export * from './interface';
 export * from './module';
 export * from './provider';
+export * from './cloudwatch.event.formatter';

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./cloudwatch.logger"), exports);
 __exportStar(require("./interface"), exports);
 __exportStar(require("./module"), exports);
 __exportStar(require("./provider"), exports);
+__exportStar(require("./cloudwatch.event.formatter"), exports);

package/dist/module.js

@@ -23,10 +23,7 @@ let LoggerModule = exports.LoggerModule = LoggerModule_1 = class LoggerModule {
         return {
             module: LoggerModule_1,
             exports: [cloudwatchProvider, cloudwatchProviders],
-            providers: [
-                cloudwatchProvider,
-                cloudwatchProviders,
-            ],
+            providers: [cloudwatchProvider, cloudwatchProviders],
         };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gus-eip/loggers",
-  "version": "1.0.4",
+  "version": "2.1.0",
   "description": "@gus-eip/loggers is a package designed to provide logging functionality for your Node.js applications.",
   "author": "gus",
   "readmeFilename": "README.md",
@@ -25,20 +25,13 @@
     "nodejs",
     "javascript",
     "typescript",
-    "cashify",
-    "eip-loggers",
-    "currency-exchange",
-    "conversion",
-    "money",
-    "exchange-rates"
+    "eip-loggers"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "aws-sdk": "^2.1590.0",
-    "winston": "^3.13.0",
-    "winston-aws-cloudwatch": "^3.0.0"
+    "aws-sdk": "^2.1590.0"
   },
   "devDependencies": {
     "@nestjs/common": "^10.0.2",