removed deprecated createLogger and replaced with getLogger

libs/cache/src/decorators/cacheable.ts

@@ -1,8 +1,8 @@
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { CacheProvider } from '../types';
 import { CacheKeyGenerator } from '../key-generator';
 
-const logger = createLogger('cache-decorator');
+const logger = getLogger('cache-decorator');
 
 /**
  * Method decorator for automatic caching

libs/cache/src/providers/hybrid-cache.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { CacheProvider, CacheOptions, CacheStats } from '../types';
 import { RedisCache } from './redis-cache';
 import { MemoryCache } from './memory-cache';
@@ -10,7 +10,7 @@ import { MemoryCache } from './memory-cache';
 export class HybridCache implements CacheProvider {
   private memoryCache: MemoryCache;
   private redisCache: RedisCache;
-  private logger = createLogger('hybrid-cache');
+  private logger = getLogger('hybrid-cache');
   private enableMetrics: boolean;
   private startTime = Date.now();
   

libs/cache/src/providers/memory-cache.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { CacheProvider, CacheOptions, CacheStats } from '../types';
 
 interface CacheEntry<T> {
@@ -12,7 +12,7 @@ interface CacheEntry<T> {
  */
 export class MemoryCache implements CacheProvider {
   private store = new Map<string, CacheEntry<any>>();
-  private logger = createLogger('memory-cache');
+  private logger = getLogger('memory-cache');
   private defaultTTL: number;
   private keyPrefix: string;
   private maxItems: number;

libs/cache/src/providers/redis-cache.ts

@@ -1,5 +1,5 @@
 import Redis from 'ioredis';
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { dragonflyConfig } from '@stock-bot/config';
 import { CacheProvider, CacheOptions, CacheStats } from '../types';
 
@@ -8,7 +8,7 @@ import { CacheProvider, CacheOptions, CacheStats } from '../types';
  */
 export class RedisCache implements CacheProvider {
   private redis: Redis;
-  private logger = createLogger('redis-cache');
+  private logger = getLogger('redis-cache');
   private defaultTTL: number;
   private keyPrefix: string;
   private enableMetrics: boolean;

libs/data-frame/src/index.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 
 export interface DataFrameRow {
   [key: string]: any;
@@ -23,7 +23,7 @@ export class DataFrame {
   private _columns: string[];
   private _index: string;
   private _dtypes: Record<string, 'number' | 'string' | 'boolean' | 'date'>;
-  private logger = createLogger('dataframe');
+  private logger = getLogger('dataframe');
 
   constructor(data: DataFrameRow[] = [], options: DataFrameOptions = {}) {
     this.data = [...data];

libs/event-bus/src/index.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'eventemitter3';
 import Redis from 'ioredis';
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { dragonflyConfig } from '@stock-bot/config';
 
 export interface EventBusMessage {
@@ -51,7 +51,7 @@ export class EventBus extends EventEmitter {
     this.useStreams = options.useStreams ?? true;
     this.maxRetries = options.maxRetries ?? 3;
     this.retryDelay = options.retryDelay ?? 1000;
-    this.logger = createLogger(`event-bus:${this.serviceName}`);
+    this.logger = getLogger(`event-bus:${this.serviceName}`);
 
     this.redis = new Redis({
       host: dragonflyConfig.DRAGONFLY_HOST,

libs/http/src/client.ts

@@ -14,7 +14,7 @@ export class HttpClient {
 
   constructor(config: HttpClientConfig = {}, logger?: Logger) {
     this.config = config;
-    this.logger = logger?.child({ component: 'http' });
+    this.logger = logger?.child('http-client');
   }
 
   // Convenience methods
@@ -64,11 +64,19 @@ export class HttpClient {
 
       return response;
     } catch (error) {
-      this.logger?.warn('HTTP request failed', {
-        method: finalConfig.method,
-        url: finalConfig.url,
-        error: (error as Error).message,
-      });
+      if( this.logger?.getServiceName() === 'proxy-service' ) {
+        this.logger?.debug('HTTP request failed', {
+          method: finalConfig.method,
+          url: finalConfig.url,
+          error: (error as Error).message,
+        });
+      }else{
+        this.logger?.warn('HTTP request failed', {
+          method: finalConfig.method,
+          url: finalConfig.url,
+          error: (error as Error).message,
+        });
+      }
       throw error;
     }
   }
@@ -117,8 +125,7 @@ export class HttpClient {
       return response;
     } catch (error) {
       const elapsed = Date.now() - startTime;
-      console.log(`Request Aborted after ${elapsed}ms due to timeout of ${timeout}ms`);
-
+      this.logger?.debug('Adapter failed successful', { url: config.url, elapsedMs: Date.now() - startTime });
       clearTimeout(timeoutId);
       
       // Handle timeout

libs/logger/src/index.ts

@@ -7,7 +7,6 @@
 // Core logger classes and functions
 export { 
   Logger, 
-  createLogger, 
   getLogger,
   shutdownLoggers
 } from './logger';

libs/logger/src/logger.ts

@@ -29,10 +29,10 @@ function createTransports(serviceName: string): any {
       options: {
         colorize: true,
         translateTime: 'yyyy-mm-dd HH:MM:ss.l',
-        messageFormat: '[{service}] {msg}',
+        messageFormat: '[{service}{childName}] {msg}',
         singleLine: true,
         hideObject: false,
-        ignore: 'pid,hostname,service,environment,version',
+        ignore: 'pid,hostname,service,environment,version,childName',
         errorLikeObjectKeys: ['err', 'error'],
         errorProps: 'message,stack,name,code',
       }
@@ -61,7 +61,8 @@ function createTransports(serviceName: string): any {
         labels: {
           service: serviceName,
           environment: lokiConfig.LOKI_ENVIRONMENT_LABEL
-        }
+        },
+        ignore: 'childName',
       }
     });
   }
@@ -102,10 +103,13 @@ function getPinoLogger(serviceName: string): pino.Logger {
 export class Logger {
   private pino: pino.Logger;
   private context: LogContext;
+  private serviceName: string;
+  private childName?: string;
 
   constructor(serviceName: string, context: LogContext = {}) {
     this.pino = getPinoLogger(serviceName);
     this.context = context;
+    this.serviceName = serviceName;
   }
 
   /**
@@ -198,12 +202,31 @@ export class Logger {
   /**
    * Create child logger with additional context
    */
-  child(context: LogContext): Logger {
+  child(serviceName: string, context?: LogContext): Logger {
       // Create child logger that shares the same pino instance with additional context
     const childLogger = Object.create(Logger.prototype);
+    childLogger.serviceName = this.serviceName;
+    childLogger.childName = serviceName;
     childLogger.context = { ...this.context, ...context };
-    childLogger.pino = this.pino.child(context); // Let pino handle level inheritance naturally
+    const childBindings = {
+      service: this.serviceName,
+      childName: ' -> ' + serviceName,
+      ...(context || childLogger.context)
+    };
+    
+    childLogger.pino = this.pino.child(childBindings);
     return childLogger;
+  // }
+    // childLogger.pino = this.pino.child(context || childLogger.context); // Let pino handle level inheritance naturally
+    // return childLogger;
+  }
+
+  // Getters for service and context
+  getServiceName(): string {
+    return this.serviceName;
+  }
+  getChildName(): string | undefined {
+    return this.childName;
   }
 }
 
@@ -214,13 +237,6 @@ export function getLogger(serviceName: string, context?: LogContext): Logger {
   return new Logger(serviceName, context);
 }
 
-/**
- * Keep backward compatibility
- */
-export function createLogger(serviceName: string): pino.Logger {
-  return getPinoLogger(serviceName);
-}
-
 /**
  * Gracefully shutdown all logger instances
  * This should be called during application shutdown to ensure all logs are flushed

libs/logger/test/basic.test.ts

@@ -5,7 +5,7 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { Logger, getLogger, createLogger, shutdownLoggers } from '../src';
+import { Logger, getLogger, shutdownLoggers } from '../src';
 import { loggerTestHelpers } from './setup';
 
 describe('Basic Logger Tests', () => {
@@ -32,13 +32,6 @@ describe('Basic Logger Tests', () => {
         anotherTestLoggerInstance.logger.info('Factory test');
       }).not.toThrow();
     });
-
-    it('should create Pino logger with createLogger', () => {
-      expect(typeof createLogger).toBe('function');
-      
-      // Test that createLogger function exists
-      expect(() => createLogger).not.toThrow();
-    });
   });
 
   describe('Logger Methods', () => {

libs/logger/test/integration.test.ts

@@ -7,7 +7,6 @@
 import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
 import {
   Logger,
-  createLogger,
   getLogger,
   shutdownLoggers
 } from '../src';
@@ -101,7 +100,6 @@ describe('Logger Integration Tests', () => {
   describe('Factory Functions', () => {
     it('should export factory functions', () => {
       // Verify that the factory functions are exported and callable
-      expect(typeof createLogger).toBe('function');
       expect(typeof getLogger).toBe('function');
     });
 

libs/logger/test/setup.ts

@@ -19,63 +19,7 @@ const originalConsole = {
 
 // Create a test logger helper
 export const loggerTestHelpers = {
-  /**
-   * Create a test logger instance that captures logs locally.
-   */
-  createTestLogger: (serviceName: string = 'test-service', initialContext: any = {}) => {
-    const capturedLogsArray: any[] = [];
 
-    const createLoggerMockInstance = (currentContext: any): Logger => {
-      const buildLogEntry = (level: string, messageOrObject: string | object, metadata?: any) => {
-        const logObject: any = { level, service: serviceName, ...currentContext };
-
-        if (typeof messageOrObject === 'string') {
-          logObject.msg = messageOrObject;
-          if (metadata) {
-            Object.assign(logObject, metadata);
-          }
-        } else { // messageOrObject is an object
-          Object.assign(logObject, messageOrObject); // Merge fields from the message object
-          if (metadata) { // If metadata is also provided (e.g. logger.error({code: 1}, {extra: 'data'}))
-            Object.assign(logObject, metadata);
-          }
-          // Ensure 'msg' field exists, defaulting if necessary
-          if (typeof logObject.msg === 'undefined') {
-            // If the second arg was a string, it might have been intended as the message
-            if (typeof metadata === 'string') {
-              logObject.msg = metadata;
-            } else {
-              logObject.msg = 'Object logged';
-            }
-          }
-        }
-        capturedLogsArray.push(logObject);
-      };
-
-      return {
-        // serviceName, // For inspection if needed, though logs capture it
-        context: currentContext, // For inspection
-        debug: (msgOrObj: string | object, meta?: any) => buildLogEntry('debug', msgOrObj, meta),
-        info:  (msgOrObj: string | object, meta?: any) => buildLogEntry('info',  msgOrObj, meta),
-        warn:  (msgOrObj: string | object, meta?: any) => buildLogEntry('warn',  msgOrObj, meta),
-        error: (msgOrObj: string | object, metaOrMsg?: any) => buildLogEntry('error', msgOrObj, metaOrMsg),
-        child: (childContext: any): Logger => {
-          // Children will log to the same capturedLogsArray
-          return createLoggerMockInstance({ ...currentContext, ...childContext });
-        }
-      } as any; // Cast to Logger, assuming it fulfills the interface for testing purposes
-    };
-
-    const loggerInstance = createLoggerMockInstance(initialContext);
-
-    return {
-      logger: loggerInstance,
-      getCapturedLogs: () => [...capturedLogsArray],
-      clearCapturedLogs: () => {
-        capturedLogsArray.length = 0;
-      }
-    };
-  },
 
   /**
    * Mock Loki transport

libs/questdb-client/src/client.ts

@@ -1,6 +1,6 @@
 import { Pool } from 'pg';
 import { questdbConfig } from '@stock-bot/config';
-import { createLogger, Logger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import type {
   QuestDBClientConfig,
   QuestDBConnectionOptions,
@@ -24,7 +24,7 @@ export class QuestDBClient {
   private pgPool: Pool | null = null;
   private readonly config: QuestDBClientConfig;
   private readonly options: QuestDBConnectionOptions;
-  private readonly logger = createLogger('QuestDBClient');
+  private readonly logger = getLogger('QuestDBClient');
   private readonly healthMonitor: QuestDBHealthMonitor;
   private readonly influxWriter: QuestDBInfluxWriter;
   private readonly schemaManager: QuestDBSchemaManager;

libs/strategy-engine/src/index.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'eventemitter3';
-import { createLogger, Logger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { EventBus } from '@stock-bot/event-bus';
 import { DataFrame } from '@stock-bot/data-frame';
 
@@ -83,7 +83,7 @@ export abstract class BaseStrategy extends EventEmitter {
     super();
     this.config = config;
     this.eventBus = eventBus;
-    this.logger = createLogger(`strategy:${config.id}`);
+    this.logger = getLogger(`strategy:${config.id}`);
   }
 
   // Abstract methods that must be implemented by concrete strategies
@@ -204,7 +204,7 @@ export class StrategyEngine extends EventEmitter {
   constructor(eventBus: EventBus) {
     super();
     this.eventBus = eventBus;
-    this.logger = createLogger('strategy-engine');
+    this.logger = getLogger('strategy-engine');
   }
 
   async initialize(): Promise<void> {

libs/vector-engine/src/index.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@stock-bot/logger';
+import { getLogger } from '@stock-bot/logger';
 import { DataFrame } from '@stock-bot/data-frame';
 import { atr, sma, ema, rsi, macd, bollingerBands } from '@stock-bot/utils';
 
@@ -55,7 +55,7 @@ export interface VectorizedTrade {
 
 // Vectorized strategy engine
 export class VectorEngine {
-  private logger = createLogger('vector-engine');
+  private logger = getLogger('vector-engine');
   private operations: Map<string, VectorOperation> = new Map();
 
   constructor() {