@unito/integration-sdk 2.3.3 → 2.3.5

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,13 @@ 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.error && { error: processedMetadata.error }),
+            };
+            const metadataString = Object.keys(metadata).length > 1 ? ` ${JSON.stringify(metadata, null, 2)}` : ` ${JSON.stringify(metadata)}`;
+            console[logLevel](`${coloredMessage}${metadataString}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -204,6 +211,55 @@ 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 `${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', logLevel)}: ${util.styleText('red', message)}`;
+            }
+            else if (statusCode >= 300) {
+                return `${util.styleText('yellow', logLevel)}: ${util.styleText('yellow', message)}`;
+            }
+            else if (statusCode >= 200) {
+                return `${util.styleText('green', logLevel)}: ${util.styleText('green', message)}`;
+            }
+        }
+        // Fall back to log level if no status code found
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                return `${util.styleText('red', logLevel)}: ${util.styleText('red', message)}`;
+            case LogLevel.WARN:
+                return `${util.styleText('yellow', logLevel)}: ${util.styleText('yellow', message)}`;
+            case LogLevel.INFO:
+            case LogLevel.LOG:
+                return `${util.styleText('green', logLevel)}: ${util.styleText('green', message)}`;
+            case LogLevel.DEBUG:
+                return `${util.styleText('cyan', logLevel)}: ${util.styleText('cyan', message)}`;
+            default:
+                return `${logLevel}: ${message}`;
+        }
+    }
 }
 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,13 @@ 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.error && { error: processedMetadata.error }),
+            };
+            const metadataString = Object.keys(metadata).length > 1 ? ` ${JSON.stringify(metadata, null, 2)}` : ` ${JSON.stringify(metadata)}`;
+            console[logLevel](`${coloredMessage}${metadataString}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -176,5 +183,54 @@ 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 `${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', logLevel)}: ${styleText('red', message)}`;
+            }
+            else if (statusCode >= 300) {
+                return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
+            }
+            else if (statusCode >= 200) {
+                return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
+            }
+        }
+        // Fall back to log level if no status code found
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
+            case LogLevel.WARN:
+                return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
+            case LogLevel.INFO:
+            case LogLevel.LOG:
+                return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
+            case LogLevel.DEBUG:
+                return `${styleText('cyan', logLevel)}: ${styleText('cyan', message)}`;
+            default:
+                return `${logLevel}: ${message}`;
+        }
+    }
 }
 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,134 @@ 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,
+            });
+        }
+    });
+    it('only logs date for metadata of successful requests in development', testContext => {
+        const originalEnv = process.env.NODE_ENV;
+        try {
+            process.env.NODE_ENV = 'development';
+            const infoSpy = testContext.mock.method(global.console, 'info', () => { });
+            const metadata = {
+                correlation_id: '123456789',
+                http: { method: 'GET', status_code: 200 },
+                user_id: 'user123',
+                request_id: 'req456',
+            };
+            const logger = new Logger(metadata);
+            logger.info('Test message without error');
+            assert.strictEqual(infoSpy.mock.calls.length, 1);
+            const loggedOutput = infoSpy.mock.calls[0]?.arguments[0];
+            assert.ok(loggedOutput.includes('Test message without error'));
+            // Should only contain date in metadata JSON
+            const metadataMatch = loggedOutput.match(/({.*})/);
+            assert.ok(metadataMatch);
+            const parsedMetadata = JSON.parse(metadataMatch[1]);
+            assert.ok(parsedMetadata.date);
+            assert.strictEqual(Object.keys(parsedMetadata).length, 1); // What matters: Only the date
+        }
+        finally {
+            process.env.NODE_ENV = originalEnv;
+        }
+    });
+    it('logs date & error stack for metadata of failed requests in development', testContext => {
+        const originalEnv = process.env.NODE_ENV;
+        try {
+            process.env.NODE_ENV = 'development';
+            const metadata = {
+                correlation_id: '123456789',
+                http: { method: 'GET', status_code: 200 },
+                user_id: 'user123',
+                request_id: 'req456',
+            };
+            const logger = new Logger(metadata);
+            // Test with error metadata
+            const errorSpy = testContext.mock.method(global.console, 'error', () => { });
+            logger.error('Test message with error', { error: { code: 500, message: 'Internal Server Error' } });
+            assert.strictEqual(errorSpy.mock.calls.length, 1);
+            const errorLoggedOutput = errorSpy.mock.calls[0]?.arguments[0];
+            assert.ok(errorLoggedOutput.includes('Test message with error'));
+            // Should contain both date and error in metadata JSON
+            const errorMetadataMatch = errorLoggedOutput.match(/({.*})/s);
+            assert.ok(errorMetadataMatch);
+            const parsedErrorMetadata = JSON.parse(errorMetadataMatch[1]);
+            assert.ok(parsedErrorMetadata.date);
+            assert.ok(parsedErrorMetadata.error);
+            assert.deepEqual(parsedErrorMetadata.error, { code: 500, message: 'Internal Server Error' });
+            assert.strictEqual(Object.keys(parsedErrorMetadata).length, 2); // What matters: Date and error only
+        }
+        finally {
+            process.env.NODE_ENV = originalEnv;
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "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,17 @@ 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.error && { error: processedMetadata.error }),
+      };
+
+      const metadataString =
+        Object.keys(metadata).length > 1 ? ` ${JSON.stringify(metadata, null, 2)}` : ` ${JSON.stringify(metadata)}`;
+
+      console[logLevel](`${coloredMessage}${metadataString}`);
     } else {
       console[logLevel](JSON.stringify(processedLogs));
     }
@@ -209,6 +221,57 @@ 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 `${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', logLevel)}: ${styleText('red', message)}`;
+      } else if (statusCode >= 300) {
+        return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
+      } else if (statusCode >= 200) {
+        return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
+      }
+    }
+
+    // Fall back to log level if no status code found
+    switch (logLevel) {
+      case LogLevel.ERROR:
+        return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
+      case LogLevel.WARN:
+        return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
+      case LogLevel.INFO:
+      case LogLevel.LOG:
+        return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
+      case LogLevel.DEBUG:
+        return `${styleText('cyan', logLevel)}: ${styleText('cyan', message)}`;
+      default:
+        return `${logLevel}: ${message}`;
+    }
+  }
 }
 
 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,155 @@ 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,
+      });
+    }
+  });
+
+  it('only logs date for metadata of successful requests in development', testContext => {
+    const originalEnv = process.env.NODE_ENV;
+
+    try {
+      process.env.NODE_ENV = 'development';
+
+      const infoSpy = testContext.mock.method(global.console, 'info', () => {});
+      const metadata = {
+        correlation_id: '123456789',
+        http: { method: 'GET', status_code: 200 },
+        user_id: 'user123',
+        request_id: 'req456',
+      };
+
+      const logger = new Logger(metadata);
+
+      logger.info('Test message without error');
+      assert.strictEqual(infoSpy.mock.calls.length, 1);
+
+      const loggedOutput = infoSpy.mock.calls[0]?.arguments[0];
+      assert.ok(loggedOutput.includes('Test message without error'));
+
+      // Should only contain date in metadata JSON
+      const metadataMatch = loggedOutput.match(/({.*})/);
+      assert.ok(metadataMatch);
+      const parsedMetadata = JSON.parse(metadataMatch[1]);
+      assert.ok(parsedMetadata.date);
+      assert.strictEqual(Object.keys(parsedMetadata).length, 1); // What matters: Only the date
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+    }
+  });
+
+  it('logs date & error stack for metadata of failed requests in development', testContext => {
+    const originalEnv = process.env.NODE_ENV;
+
+    try {
+      process.env.NODE_ENV = 'development';
+
+      const metadata = {
+        correlation_id: '123456789',
+        http: { method: 'GET', status_code: 200 },
+        user_id: 'user123',
+        request_id: 'req456',
+      };
+
+      const logger = new Logger(metadata);
+
+      // Test with error metadata
+      const errorSpy = testContext.mock.method(global.console, 'error', () => {});
+      logger.error('Test message with error', { error: { code: 500, message: 'Internal Server Error' } });
+      assert.strictEqual(errorSpy.mock.calls.length, 1);
+
+      const errorLoggedOutput = errorSpy.mock.calls[0]?.arguments[0];
+      assert.ok(errorLoggedOutput.includes('Test message with error'));
+
+      // Should contain both date and error in metadata JSON
+      const errorMetadataMatch = errorLoggedOutput.match(/({.*})/s);
+      assert.ok(errorMetadataMatch);
+      const parsedErrorMetadata = JSON.parse(errorMetadataMatch[1]);
+      assert.ok(parsedErrorMetadata.date);
+      assert.ok(parsedErrorMetadata.error);
+      assert.deepEqual(parsedErrorMetadata.error, { code: 500, message: 'Internal Server Error' });
+      assert.strictEqual(Object.keys(parsedErrorMetadata).length, 2); // What matters: Date and error only
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+    }
+  });
 });