@unito/integration-sdk 2.3.4 → 2.3.5

package/dist/src/index.cjs

@@ -165,9 +165,10 @@ class Logger {
             const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
             const metadata = {
                 date: new Date(processedLogs.date).toISOString(),
-                ...processedMetadata,
+                ...(processedMetadata.error && { error: processedMetadata.error }),
             };
-            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
+            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));
@@ -219,9 +220,8 @@ class Logger {
      */
     static colorize(message, metadata, logLevel) {
         if (!process.stdout.isTTY) {
-            return message;
+            return `${logLevel}: ${message}`;
         }
-        const logOutput = `${logLevel}: ${message}`;
         // Extract status code from logs
         let statusCode;
         if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
@@ -236,28 +236,28 @@ class Logger {
         // Color based on status code first
         if (statusCode) {
             if (statusCode >= 400) {
-                return util.styleText('red', logOutput);
+                return `${util.styleText('red', logLevel)}: ${util.styleText('red', message)}`;
             }
             else if (statusCode >= 300) {
-                return util.styleText('yellow', logOutput);
+                return `${util.styleText('yellow', logLevel)}: ${util.styleText('yellow', message)}`;
             }
             else if (statusCode >= 200) {
-                return util.styleText('green', logOutput);
+                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', logOutput);
+                return `${util.styleText('red', logLevel)}: ${util.styleText('red', message)}`;
             case LogLevel.WARN:
-                return util.styleText('yellow', logOutput);
+                return `${util.styleText('yellow', logLevel)}: ${util.styleText('yellow', message)}`;
             case LogLevel.INFO:
             case LogLevel.LOG:
-                return util.styleText('green', logOutput);
+                return `${util.styleText('green', logLevel)}: ${util.styleText('green', message)}`;
             case LogLevel.DEBUG:
-                return util.styleText('cyan', logOutput);
+                return `${util.styleText('cyan', logLevel)}: ${util.styleText('cyan', message)}`;
             default:
-                return logOutput;
+                return `${logLevel}: ${message}`;
         }
     }
 }

package/dist/src/resources/logger.js

@@ -137,9 +137,10 @@ export default class Logger {
             const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
             const metadata = {
                 date: new Date(processedLogs.date).toISOString(),
-                ...processedMetadata,
+                ...(processedMetadata.error && { error: processedMetadata.error }),
             };
-            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
+            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));
@@ -191,9 +192,8 @@ export default class Logger {
      */
     static colorize(message, metadata, logLevel) {
         if (!process.stdout.isTTY) {
-            return message;
+            return `${logLevel}: ${message}`;
         }
-        const logOutput = `${logLevel}: ${message}`;
         // Extract status code from logs
         let statusCode;
         if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
@@ -208,28 +208,28 @@ export default class Logger {
         // Color based on status code first
         if (statusCode) {
             if (statusCode >= 400) {
-                return styleText('red', logOutput);
+                return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
             }
             else if (statusCode >= 300) {
-                return styleText('yellow', logOutput);
+                return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
             }
             else if (statusCode >= 200) {
-                return styleText('green', logOutput);
+                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', logOutput);
+                return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
             case LogLevel.WARN:
-                return styleText('yellow', logOutput);
+                return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
             case LogLevel.INFO:
             case LogLevel.LOG:
-                return styleText('green', logOutput);
+                return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
             case LogLevel.DEBUG:
-                return styleText('cyan', logOutput);
+                return `${styleText('cyan', logLevel)}: ${styleText('cyan', message)}`;
             default:
-                return logOutput;
+                return `${logLevel}: ${message}`;
         }
     }
 }

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

@@ -250,4 +250,61 @@ describe('Logger', () => {
             });
         }
     });
+    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.4",
+  "version": "2.3.5",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/resources/logger.ts

@@ -168,10 +168,13 @@ export default class Logger {
 
       const metadata = {
         date: new Date(processedLogs.date).toISOString(),
-        ...processedMetadata,
+        ...(processedMetadata.error && { error: processedMetadata.error }),
       };
 
-      console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
+      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));
     }
@@ -228,11 +231,9 @@ export default class Logger {
    */
   private static colorize(message: string, metadata: Value, logLevel: LogLevel): string {
     if (!process.stdout.isTTY) {
-      return message;
+      return `${logLevel}: ${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)) {
@@ -248,27 +249,27 @@ export default class Logger {
     // Color based on status code first
     if (statusCode) {
       if (statusCode >= 400) {
-        return styleText('red', logOutput);
+        return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
       } else if (statusCode >= 300) {
-        return styleText('yellow', logOutput);
+        return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
       } else if (statusCode >= 200) {
-        return styleText('green', logOutput);
+        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', logOutput);
+        return `${styleText('red', logLevel)}: ${styleText('red', message)}`;
       case LogLevel.WARN:
-        return styleText('yellow', logOutput);
+        return `${styleText('yellow', logLevel)}: ${styleText('yellow', message)}`;
       case LogLevel.INFO:
       case LogLevel.LOG:
-        return styleText('green', logOutput);
+        return `${styleText('green', logLevel)}: ${styleText('green', message)}`;
       case LogLevel.DEBUG:
-        return styleText('cyan', logOutput);
+        return `${styleText('cyan', logLevel)}: ${styleText('cyan', message)}`;
       default:
-        return logOutput;
+        return `${logLevel}: ${message}`;
     }
   }
 }

package/test/resources/logger.test.ts

@@ -291,4 +291,73 @@ describe('Logger', () => {
       });
     }
   });
+
+  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;
+    }
+  });
 });