Merge pull request #2242 from contentstack/feat/DX-3646

feat: session based logs with date hierarchy

Author: harshitha-cstk

packages/contentstack-utilities/src/logger/log.ts

@@ -5,6 +5,7 @@ import { default as Logger } from './logger';
 import { CLIErrorHandler } from './cli-error-handler';
 import { ErrorContext } from '../interfaces';
 import { configHandler } from '..';
+import { getSessionLogPath } from './session-path';
 
 let loggerInstance: Logger | null = null;
 
@@ -105,4 +106,6 @@ function getLogPath(): string {
   return path.join(os.homedir(), 'contentstack', 'logs');
 }
 
+// Re-export getSessionLogPath for external use
+export { getSessionLogPath } from './session-path';
 export { v2Logger, cliErrorHandler, handleAndLogError, getLogPath };

packages/contentstack-utilities/src/logger/logger.ts

@@ -37,7 +37,9 @@ export default class Logger {
   }
 
   getLoggerInstance(level: 'error' | 'info' | 'warn' | 'debug' | 'hidden' = 'info'): winston.Logger {
-    const filePath = normalize(process.env.CS_CLI_LOG_PATH || this.config.basePath).replace(/^(\.\.(\/|\\|$))+/, '');
+    // Use session-based path for date-organized logging
+    const sessionPath = getSessionLogPath();
+    const filePath = normalize(sessionPath).replace(/^(\.\.(\/|\\|$))+/, '');
     return this.createLogger(level === 'hidden' ? 'error' : level, filePath);
   }
 

packages/contentstack-utilities/src/logger/session-path.ts

@@ -0,0 +1,51 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { configHandler, formatDate, formatTime } from '..';
+import { getLogPath } from './log';
+
+/**
+ * Get the session-based log path for date-organized logging
+ * Structure: {basePath}/{YYYY-MM-DD}/{command}-{YYYYMMDD-HHMMSS}-{sessionId}/
+ * 
+ * @returns The session-specific log directory path
+ */
+export function getSessionLogPath(): string {
+  // Get base log path
+  const basePath = getLogPath();
+
+  // Get current date in YYYY-MM-DD format
+  const now = new Date();
+  const dateStr = now.toISOString().split('T')[0]; // YYYY-MM-DD
+
+  // Get command ID (fallback to 'unknown' if not set)
+  let commandId = configHandler.get('currentCommandId') || 'unknown';
+  // Sanitize command ID - remove colons and replace with hyphens for folder name
+  commandId = commandId?.replace(/:/g, '-');
+
+  // Use helper methods to format date and time
+  const dateStrFormatted = formatDate(now); // YYYYMMDD
+  const timeStrFormatted = formatTime(now); // HHMMSS
+  const timestamp = `${dateStrFormatted}-${timeStrFormatted}`; // YYYYMMDD-HHMMSS
+
+  let sessionId = configHandler.get('sessionId');
+  if (!sessionId) {
+    // Format: first 8 chars of command + timestamp (YYYYMMDDHHMMSS)
+    const timestampForId = `${dateStrFormatted}${timeStrFormatted}`; // YYYYMMDDHHMMSS
+    const commandHash = commandId.substring(0, 8).padEnd(8, '0'); // Use first 8 chars of command
+    sessionId = `${commandHash}-${timestampForId}`;
+  }
+
+  // Create session folder name: command-YYYYMMDD-HHMMSS-sessionId
+  const sessionFolderName = `${commandId}-${timestamp}-${sessionId}`;
+
+  // Build full session path
+  const sessionPath = path.join(basePath, dateStr, sessionFolderName);
+
+  // Ensure directory exists
+  if (!fs.existsSync(sessionPath)) {
+    fs.mkdirSync(sessionPath, { recursive: true });
+  }
+
+  return sessionPath;
+}
+

packages/contentstack-utilities/test/unit/cliErrorHandler.test.ts

@@ -36,7 +36,7 @@ describe('CLIErrorHandler', () => {
     expect(hidden).to.equal(true);
   });
 
-  fancy.it('should extract debug payload correctly', () => {
+  fancy.it('should extract error payload correctly', () => {
     const error = new Error('API error');
     (error as any).status = 500;
     (error as any).statusText = 'Internal Server Error';
@@ -52,6 +52,7 @@ describe('CLIErrorHandler', () => {
       data: { error: 'fail' },
       headers: { 'content-type': 'application/json' },
     };
+    (error as any).status = 500; // Also set status on error directly
 
     const debugPayload = errorHandler['extractErrorPayload'](error);
     expect(debugPayload.request.method).to.equal('GET');

packages/contentstack-utilities/test/unit/helper.test.ts

@@ -27,7 +27,7 @@ describe('Testing the Validate function', () => {
 describe('Testing the getBranchFromAlias function', () => {
   describe('When branch alias exists and resolves successfully', () => {
     it('should return the branch UID', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: 'main-branch' })
         })
@@ -60,7 +60,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for null branchAlias', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: 'main-branch' })
         })
@@ -76,7 +76,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for undefined branchAlias', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: 'main-branch' })
         })
@@ -92,14 +92,14 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for non-string branchAlias', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: 'main-branch' })
         })
       };
 
       try {
-        await getBranchFromAlias(mockStack, 123);
+        await getBranchFromAlias(mockStack, 123 as any);
         expect.fail('Expected function to throw an error');
       } catch (error) {
         expect(error).to.be.instanceOf(Error);
@@ -108,7 +108,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for empty string branchAlias', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: 'main-branch' })
         })
@@ -126,7 +126,7 @@ describe('Testing the getBranchFromAlias function', () => {
 
   describe('When branch alias does not exist', () => {
     it('should throw an error', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => {
             throw new Error('Branch alias not found');
@@ -146,7 +146,7 @@ describe('Testing the getBranchFromAlias function', () => {
 
   describe('When response is missing UID', () => {
     it('should throw error for response without uid', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ name: 'main-branch' }) // missing uid
         })
@@ -162,7 +162,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for response with null uid', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: null })
         })
@@ -178,7 +178,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for response with undefined uid', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: undefined })
         })
@@ -194,7 +194,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for response with empty string uid', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({ uid: '' })
         })
@@ -210,7 +210,7 @@ describe('Testing the getBranchFromAlias function', () => {
     });
 
     it('should throw error for empty response object', async () => {
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => ({})
         })
@@ -229,7 +229,7 @@ describe('Testing the getBranchFromAlias function', () => {
   describe('When network error occurs', () => {
     it('should throw the network error', async () => {
       const networkError = new Error('Network timeout');
-      const mockStack = {
+      const mockStack: any = {
         branchAlias: (alias: string) => ({
           fetch: async () => {
             throw networkError;

packages/contentstack-utilities/test/unit/logger.test.ts

@@ -1,7 +1,12 @@
 import { expect } from 'chai';
 import { fancy } from 'fancy-test';
 import sinon from 'sinon';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 import Logger from '../../src/logger/logger';
+import { getSessionLogPath } from '../../src/logger/session-path';
+import configHandler from '../../src/config-handler';
 
 describe('Logger', () => {
   let logger: Logger;
@@ -32,10 +37,10 @@ describe('Logger', () => {
       other: 'safe',
     };
 
-    const redacted = logger['redact'](testMeta);
-    expect(redacted.password).to.equal('[REDACTED]');
+    // Test file mode redaction (consoleMode = false)
+    const redacted = logger['redact'](testMeta, false);
+    // In file mode, only token and secret are redacted (not password or email)
     expect(redacted.token).to.equal('[REDACTED]');
-    expect(redacted.email).to.equal('[REDACTED]');
     expect(redacted.other).to.equal('safe');
   });
 
@@ -69,6 +74,7 @@ describe('Logger', () => {
   fancy.it('should log error messages using error method', () => {
     const errorLogger = logger['loggers'].error;
     const spy = sinon.spy();
+    const originalError = errorLogger.error.bind(errorLogger);
     errorLogger.error = spy;
 
     logger.error('error message', { some: 'meta' });
@@ -87,25 +93,38 @@ describe('Logger', () => {
   fancy.it('logSuccess should call success info logger', () => {
     const successLogger = logger['loggers'].success;
     const spy = sinon.spy();
-    successLogger.info = spy;
+    const originalLog = successLogger.log.bind(successLogger);
+    successLogger.log = spy;
 
     logger.logSuccess({ type: 'test', message: 'Success message' });
     expect(spy.calledOnce).to.be.true;
-    expect(spy.args[0][0].message).to.equal('Success message');
+    // logSuccess creates a logPayload object with level, message, timestamp, and meta
+    const logPayload = spy.args[0][0];
+    expect(logPayload.message).to.equal('Success message');
+    expect(logPayload.meta.type).to.equal('test');
+    
+    // Restore original
+    successLogger.log = originalLog;
   });
 
   fancy.it('shouldLog should handle file target level filtering', () => {
     const result = logger['shouldLog']('debug', 'file'); // logLevel = info
     expect(result).to.equal(false);
   });
 
-  fancy.it('success logger should include success type in meta', () => {
+  fancy.it('success logger should call log method', () => {
+    const successLogger = logger['loggers'].success;
     const spy = sinon.spy();
-    logger['loggers'].success.info = spy;
+    const originalLog = successLogger.log.bind(successLogger);
+    successLogger.log = spy;
 
     logger.success('It worked!', { extra: 'meta' });
     expect(spy.calledOnce).to.be.true;
-    expect(spy.args[0][1].type).to.equal('success');
+    // success() calls log('success', message, meta)
+    expect(spy.calledWith('success', 'It worked!', { extra: 'meta' })).to.be.true;
+    
+    // Restore original
+    successLogger.log = originalLog;
   });
 
   fancy.it('logError with hidden true logs to debug logger', () => {
@@ -135,9 +154,16 @@ describe('Logger', () => {
       token: 'abc',
       [Symbol.for('splat')]: [{ password: '1234' }],
     };
-    const result = logger['redact'](obj);
+    // Test file mode (consoleMode = false) - token is redacted, password is not
+    const result = logger['redact'](obj, false);
     expect(result.token).to.equal('[REDACTED]');
-    expect(result[Symbol.for('splat')][0].password).to.equal('[REDACTED]');
+    // In file mode, password is not redacted
+    expect(result[Symbol.for('splat')][0].password).to.equal('1234');
+    
+    // Test console mode (consoleMode = true) - both token and password are redacted
+    const consoleResult = logger['redact'](obj, true);
+    expect(consoleResult.token).to.equal('[REDACTED]');
+    expect(consoleResult[Symbol.for('splat')][0].password).to.equal('[REDACTED]');
   });
 
   fancy.it('redact should return original if klona fails', () => {