@unito/integration-sdk 2.3.3 → 2.3.4

package/dist/src/index.cjs

@@ -3,6 +3,7 @@
 var integrationApi = require('@unito/integration-api');
 var cachette = require('cachette');
 var crypto = require('crypto');
+var util = require('util');
 var express = require('express');
 var busboy = require('busboy');
 var https = require('https');
@@ -161,7 +162,12 @@ class Logger {
             status: logLevel,
         };
         if (process.env.NODE_ENV === 'development') {
-            console[logLevel](JSON.stringify(processedLogs, null, 2));
+            const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
+            const metadata = {
+                date: new Date(processedLogs.date).toISOString(),
+                ...processedMetadata,
+            };
+            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -204,6 +210,56 @@ class Logger {
         }
         return prunedMetadata;
     }
+    /**
+     * Colorizes the log message based on the log level and status codes.
+     * @param message The message to colorize.
+     * @param metadata The metadata associated with the log.
+     * @param logLevel The log level of the message.
+     * @returns The colorized output string.
+     */
+    static colorize(message, metadata, logLevel) {
+        if (!process.stdout.isTTY) {
+            return message;
+        }
+        const logOutput = `${logLevel}: ${message}`;
+        // Extract status code from logs
+        let statusCode;
+        if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
+            const statusCodeValue = metadata.http.status_code;
+            if (typeof statusCodeValue === 'number') {
+                statusCode = statusCodeValue;
+            }
+            else if (typeof statusCodeValue === 'string') {
+                statusCode = parseInt(statusCodeValue, 10);
+            }
+        }
+        // Color based on status code first
+        if (statusCode) {
+            if (statusCode >= 400) {
+                return util.styleText('red', logOutput);
+            }
+            else if (statusCode >= 300) {
+                return util.styleText('yellow', logOutput);
+            }
+            else if (statusCode >= 200) {
+                return util.styleText('green', logOutput);
+            }
+        }
+        // Fall back to log level if no status code found
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                return util.styleText('red', logOutput);
+            case LogLevel.WARN:
+                return util.styleText('yellow', logOutput);
+            case LogLevel.INFO:
+            case LogLevel.LOG:
+                return util.styleText('green', logOutput);
+            case LogLevel.DEBUG:
+                return util.styleText('cyan', logOutput);
+            default:
+                return logOutput;
+        }
+    }
 }
 const NULL_LOGGER = new Logger({}, true);
 

package/dist/src/resources/logger.d.ts

@@ -68,6 +68,14 @@ export default class Logger {
     private send;
     private static snakifyKeys;
     private static pruneSensitiveMetadata;
+    /**
+     * Colorizes the log message based on the log level and status codes.
+     * @param message The message to colorize.
+     * @param metadata The metadata associated with the log.
+     * @param logLevel The log level of the message.
+     * @returns The colorized output string.
+     */
+    private static colorize;
 }
 export declare const NULL_LOGGER: Logger;
 export {};

package/dist/src/resources/logger.js

@@ -1,3 +1,4 @@
+import { styleText } from 'util';
 var LogLevel;
 (function (LogLevel) {
     LogLevel["ERROR"] = "error";
@@ -133,7 +134,12 @@ export default class Logger {
             status: logLevel,
         };
         if (process.env.NODE_ENV === 'development') {
-            console[logLevel](JSON.stringify(processedLogs, null, 2));
+            const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
+            const metadata = {
+                date: new Date(processedLogs.date).toISOString(),
+                ...processedMetadata,
+            };
+            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -176,5 +182,55 @@ export default class Logger {
         }
         return prunedMetadata;
     }
+    /**
+     * Colorizes the log message based on the log level and status codes.
+     * @param message The message to colorize.
+     * @param metadata The metadata associated with the log.
+     * @param logLevel The log level of the message.
+     * @returns The colorized output string.
+     */
+    static colorize(message, metadata, logLevel) {
+        if (!process.stdout.isTTY) {
+            return message;
+        }
+        const logOutput = `${logLevel}: ${message}`;
+        // Extract status code from logs
+        let statusCode;
+        if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
+            const statusCodeValue = metadata.http.status_code;
+            if (typeof statusCodeValue === 'number') {
+                statusCode = statusCodeValue;
+            }
+            else if (typeof statusCodeValue === 'string') {
+                statusCode = parseInt(statusCodeValue, 10);
+            }
+        }
+        // Color based on status code first
+        if (statusCode) {
+            if (statusCode >= 400) {
+                return styleText('red', logOutput);
+            }
+            else if (statusCode >= 300) {
+                return styleText('yellow', logOutput);
+            }
+            else if (statusCode >= 200) {
+                return styleText('green', logOutput);
+            }
+        }
+        // Fall back to log level if no status code found
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                return styleText('red', logOutput);
+            case LogLevel.WARN:
+                return styleText('yellow', logOutput);
+            case LogLevel.INFO:
+            case LogLevel.LOG:
+                return styleText('green', logOutput);
+            case LogLevel.DEBUG:
+                return styleText('cyan', logOutput);
+            default:
+                return logOutput;
+        }
+    }
 }
 export const NULL_LOGGER = new Logger({}, true);

package/dist/test/resources/logger.test.js

@@ -129,7 +129,7 @@ describe('Logger', () => {
             { id: 2, organization_id: 'b' },
         ]);
     });
-    it('prunes sensitive Metadata', { only: true }, testContext => {
+    it('prunes sensitive Metadata', testContext => {
         const logSpy = testContext.mock.method(global.console, 'log', () => { });
         assert.strictEqual(logSpy.mock.calls.length, 0);
         const metadata = {
@@ -177,4 +177,77 @@ describe('Logger', () => {
         assert.strictEqual(infoSpy.mock.calls.length, 0);
         assert.strictEqual(debugSpy.mock.calls.length, 0);
     });
+    it('colorizes logs by status codes over log levels', () => {
+        const originalEnv = process.env.NODE_ENV;
+        const originalIsTTY = process.stdout.isTTY;
+        try {
+            process.env.NODE_ENV = 'development';
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: true,
+                configurable: true,
+            });
+            // 4xx status with warn level, should be red
+            const metadataWith400 = {
+                http: { status_code: 400 },
+            };
+            const redResult = Logger['colorize']('Some error', metadataWith400, 'warn');
+            // warn level without status code, should be yellow
+            const metadataNoStatus = {};
+            const yellowResult = Logger['colorize']('Some warning', metadataNoStatus, 'warn');
+            // Results should be different colors
+            assert.notEqual(redResult, yellowResult);
+            assert.ok(redResult.includes('\x1b[31m')); // Red color code
+            assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+        }
+        finally {
+            // Restore original values
+            process.env.NODE_ENV = originalEnv;
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: originalIsTTY,
+                configurable: true,
+            });
+        }
+    });
+    it('colorizes logs with different status code ranges', () => {
+        const originalEnv = process.env.NODE_ENV;
+        const originalIsTTY = process.stdout.isTTY;
+        try {
+            process.env.NODE_ENV = 'development';
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: true,
+                configurable: true,
+            });
+            // 2xx status codes should be green
+            const successMetadata = {
+                http: { status_code: 200 },
+            };
+            const greenResult = Logger['colorize']('Success', successMetadata, 'info');
+            assert.ok(greenResult.includes('\x1b[32m')); // Green color code
+            // 3xx status codes should be yellow
+            const redirectMetadata = {
+                http: { status_code: 301 },
+            };
+            const yellowResult = Logger['colorize']('Redirect', redirectMetadata, 'info');
+            assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+            // 4xx status codes should be red
+            const clientErrorMetadata = {
+                http: { status_code: 404 },
+            };
+            const redResult = Logger['colorize']('Not Found', clientErrorMetadata, 'warn');
+            assert.ok(redResult.includes('\x1b[31m')); // Red color code
+            // 5xx status codes should be red
+            const serverErrorMetadata = {
+                http: { status_code: 500 },
+            };
+            const redResult2 = Logger['colorize']('Server Error', serverErrorMetadata, 'error');
+            assert.ok(redResult2.includes('\x1b[31m')); // Red color code
+        }
+        finally {
+            process.env.NODE_ENV = originalEnv;
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: originalIsTTY,
+                configurable: true,
+            });
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/resources/logger.ts

@@ -1,3 +1,5 @@
+import { styleText } from 'util';
+
 const enum LogLevel {
   ERROR = 'error',
   WARN = 'warn',
@@ -162,7 +164,14 @@ export default class Logger {
     };
 
     if (process.env.NODE_ENV === 'development') {
-      console[logLevel](JSON.stringify(processedLogs, null, 2));
+      const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
+
+      const metadata = {
+        date: new Date(processedLogs.date).toISOString(),
+        ...processedMetadata,
+      };
+
+      console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
     } else {
       console[logLevel](JSON.stringify(processedLogs));
     }
@@ -209,6 +218,59 @@ export default class Logger {
 
     return prunedMetadata;
   }
+
+  /**
+   * Colorizes the log message based on the log level and status codes.
+   * @param message The message to colorize.
+   * @param metadata The metadata associated with the log.
+   * @param logLevel The log level of the message.
+   * @returns The colorized output string.
+   */
+  private static colorize(message: string, metadata: Value, logLevel: LogLevel): string {
+    if (!process.stdout.isTTY) {
+      return message;
+    }
+
+    const logOutput = `${logLevel}: ${message}`;
+
+    // Extract status code from logs
+    let statusCode: number | undefined;
+    if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
+      const statusCodeValue = metadata.http.status_code;
+
+      if (typeof statusCodeValue === 'number') {
+        statusCode = statusCodeValue;
+      } else if (typeof statusCodeValue === 'string') {
+        statusCode = parseInt(statusCodeValue, 10);
+      }
+    }
+
+    // Color based on status code first
+    if (statusCode) {
+      if (statusCode >= 400) {
+        return styleText('red', logOutput);
+      } else if (statusCode >= 300) {
+        return styleText('yellow', logOutput);
+      } else if (statusCode >= 200) {
+        return styleText('green', logOutput);
+      }
+    }
+
+    // Fall back to log level if no status code found
+    switch (logLevel) {
+      case LogLevel.ERROR:
+        return styleText('red', logOutput);
+      case LogLevel.WARN:
+        return styleText('yellow', logOutput);
+      case LogLevel.INFO:
+      case LogLevel.LOG:
+        return styleText('green', logOutput);
+      case LogLevel.DEBUG:
+        return styleText('cyan', logOutput);
+      default:
+        return logOutput;
+    }
+  }
 }
 
 export const NULL_LOGGER = new Logger({}, true);

package/test/resources/logger.test.ts

@@ -155,7 +155,7 @@ describe('Logger', () => {
     ]);
   });
 
-  it('prunes sensitive Metadata', { only: true }, testContext => {
+  it('prunes sensitive Metadata', testContext => {
     const logSpy = testContext.mock.method(global.console, 'log', () => {});
     assert.strictEqual(logSpy.mock.calls.length, 0);
 
@@ -209,4 +209,86 @@ describe('Logger', () => {
     assert.strictEqual(infoSpy.mock.calls.length, 0);
     assert.strictEqual(debugSpy.mock.calls.length, 0);
   });
+
+  it('colorizes logs by status codes over log levels', () => {
+    const originalEnv = process.env.NODE_ENV;
+    const originalIsTTY = process.stdout.isTTY;
+
+    try {
+      process.env.NODE_ENV = 'development';
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: true,
+        configurable: true,
+      });
+
+      // 4xx status with warn level, should be red
+      const metadataWith400 = {
+        http: { status_code: 400 },
+      };
+      const redResult = Logger['colorize']('Some error', metadataWith400, 'warn' as any);
+
+      // warn level without status code, should be yellow
+      const metadataNoStatus = {};
+      const yellowResult = Logger['colorize']('Some warning', metadataNoStatus, 'warn' as any);
+
+      // Results should be different colors
+      assert.notEqual(redResult, yellowResult);
+      assert.ok(redResult.includes('\x1b[31m')); // Red color code
+      assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+    } finally {
+      // Restore original values
+      process.env.NODE_ENV = originalEnv;
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: originalIsTTY,
+        configurable: true,
+      });
+    }
+  });
+
+  it('colorizes logs with different status code ranges', () => {
+    const originalEnv = process.env.NODE_ENV;
+    const originalIsTTY = process.stdout.isTTY;
+
+    try {
+      process.env.NODE_ENV = 'development';
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: true,
+        configurable: true,
+      });
+
+      // 2xx status codes should be green
+      const successMetadata = {
+        http: { status_code: 200 },
+      };
+      const greenResult = Logger['colorize']('Success', successMetadata, 'info' as any);
+      assert.ok(greenResult.includes('\x1b[32m')); // Green color code
+
+      // 3xx status codes should be yellow
+      const redirectMetadata = {
+        http: { status_code: 301 },
+      };
+      const yellowResult = Logger['colorize']('Redirect', redirectMetadata, 'info' as any);
+      assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+
+      // 4xx status codes should be red
+      const clientErrorMetadata = {
+        http: { status_code: 404 },
+      };
+      const redResult = Logger['colorize']('Not Found', clientErrorMetadata, 'warn' as any);
+      assert.ok(redResult.includes('\x1b[31m')); // Red color code
+
+      // 5xx status codes should be red
+      const serverErrorMetadata = {
+        http: { status_code: 500 },
+      };
+      const redResult2 = Logger['colorize']('Server Error', serverErrorMetadata, 'error' as any);
+      assert.ok(redResult2.includes('\x1b[31m')); // Red color code
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: originalIsTTY,
+        configurable: true,
+      });
+    }
+  });
 });