@spfn/core 0.1.0-alpha.82 → 0.1.0-alpha.83

package/dist/logger/index.d.ts

@@ -19,76 +19,132 @@
  * debug < info < warn < error < fatal
  */
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/**
+ * 로그 메타데이터
+ */
+interface LogMetadata {
+    timestamp: Date;
+    level: LogLevel;
+    message: string;
+    module?: string;
+    error?: Error;
+    context?: Record<string, unknown>;
+}
+/**
+ * Transport 인터페이스
+ * 모든 Transport는 이 인터페이스를 구현해야 함
+ */
+interface Transport {
+    /**
+     * Transport 이름
+     */
+    name: string;
+    /**
+     * 최소 로그 레벨 (이 레벨 이상만 처리)
+     */
+    level: LogLevel;
+    /**
+     * 활성화 여부
+     */
+    enabled: boolean;
+    /**
+     * 로그 처리 함수
+     */
+    log(metadata: LogMetadata): Promise<void>;
+    /**
+     * Transport 종료 (리소스 정리)
+     */
+    close?(): Promise<void>;
+}
+/**
+ * Logger 설정
+ */
+interface LoggerConfig {
+    /**
+     * 기본 로그 레벨
+     */
+    level: LogLevel;
+    /**
+     * 모듈명 (context)
+     */
+    module?: string;
+    /**
+     * Transport 리스트
+     */
+    transports: Transport[];
+}
 
 /**
- * Logger Adapter Interface
+ * Logger Class
  *
- * Logger 구현을 추상화하는 Adapter 인터페이스
- * Pino, Winston, Custom 등 다양한 구현체로 교체 가능
- *
- * ✅ 구현 완료:
- * - LoggerAdapter 인터페이스 정의
- * - Child logger 지원
- * - Error + Context 지원
- *
- * 💡 향후 고려사항:
- * - Winston Adapter
- * - Bunyan Adapter
- *
- * 🔗 관련 파일:
- * - src/logger/adapters/pino.ts (Pino 구현)
- * - src/logger/adapters/custom.ts (Custom 구현)
- * - src/logger/index.ts (Adapter 선택)
+ * Central logging class with multiple transports, child loggers, and sensitive data masking.
  */
 
 /**
- * Logger Adapter 인터페이스
- *
- * 모든 Logger 구현체는 이 인터페이스를 구현해야 함
+ * Logger class
  */
-interface LoggerAdapter {
+declare class Logger {
+    private readonly config;
+    private readonly module?;
+    constructor(config: LoggerConfig);
+    /**
+     * Get current log level
+     */
+    get level(): LogLevel;
     /**
-     * Child logger 생성
+     * Create child logger (per module)
      */
-    child(module: string): LoggerAdapter;
+    child(module: string): Logger;
     /**
-     * Debug 로그
+     * Debug log
      */
     debug(message: string, context?: Record<string, unknown>): void;
     /**
-     * Info 로그
+     * Info log
      */
     info(message: string, context?: Record<string, unknown>): void;
     /**
-     * Warn 로그
+     * Warn log
      */
     warn(message: string, context?: Record<string, unknown>): void;
     warn(message: string, error: Error, context?: Record<string, unknown>): void;
     /**
-     * Error 로그
+     * Error log
      */
     error(message: string, context?: Record<string, unknown>): void;
     error(message: string, error: Error, context?: Record<string, unknown>): void;
     /**
-     * Fatal 로그
+     * Fatal log
      */
     fatal(message: string, context?: Record<string, unknown>): void;
     fatal(message: string, error: Error, context?: Record<string, unknown>): void;
     /**
-     * 리소스 정리
+     * Log processing (internal)
      */
-    close?(): Promise<void>;
+    private log;
+    /**
+     * Process Transports
+     */
+    private processTransports;
+    /**
+     * Transport log (error-safe)
+     */
+    private safeTransportLog;
+    /**
+     * Close all Transports
+     */
+    close(): Promise<void>;
 }
 
 /**
- * Logger Adapter Factory
+ * Logger Factory
  *
- * Adapter creation and initialization logic
+ * Creates and initializes the logger instance with configured transports
  */
 
 /**
  * Singleton Logger instance
  */
-declare const logger: LoggerAdapter;
+declare const logger: Logger;
 
-export { type LogLevel, type LoggerAdapter, logger };
+export { type LogLevel, Logger, type Transport, logger };

package/dist/logger/index.js

@@ -1,74 +1,6 @@
-import pino from 'pino';
-import { existsSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, statSync, readdirSync, renameSync } from 'fs';
+import { existsSync, mkdirSync, createWriteStream, statSync, readdirSync, renameSync, unlinkSync, accessSync, constants, writeFileSync } from 'fs';
 import { join } from 'path';
 
-// src/logger/adapters/pino.ts
-var PinoAdapter = class _PinoAdapter {
-  logger;
-  constructor(config) {
-    const isDevelopment = process.env.NODE_ENV === "development";
-    const transport = isDevelopment ? {
-      target: "pino-pretty",
-      options: {
-        colorize: true,
-        translateTime: "HH:MM:ss.l",
-        ignore: "pid,hostname",
-        singleLine: false,
-        messageFormat: "{module} {msg}",
-        errorLikeObjectKeys: ["err", "error"]
-      }
-    } : void 0;
-    try {
-      this.logger = pino({
-        level: config.level,
-        // 기본 필드
-        base: config.module ? { module: config.module } : void 0,
-        // Transport (pretty print in development if available)
-        transport
-      });
-    } catch (error) {
-      this.logger = pino({
-        level: config.level,
-        base: config.module ? { module: config.module } : void 0
-      });
-    }
-  }
-  child(module) {
-    const childLogger = new _PinoAdapter({ level: this.logger.level, module });
-    childLogger.logger = this.logger.child({ module });
-    return childLogger;
-  }
-  debug(message, context) {
-    this.logger.debug(context || {}, message);
-  }
-  info(message, context) {
-    this.logger.info(context || {}, message);
-  }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.warn({ err: errorOrContext, ...context }, message);
-    } else {
-      this.logger.warn(errorOrContext || {}, message);
-    }
-  }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.error({ err: errorOrContext, ...context }, message);
-    } else {
-      this.logger.error(errorOrContext || {}, message);
-    }
-  }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.fatal({ err: errorOrContext, ...context }, message);
-    } else {
-      this.logger.fatal(errorOrContext || {}, message);
-    }
-  }
-  async close() {
-  }
-};
-
 // src/logger/types.ts
 var LOG_LEVEL_PRIORITY = {
   debug: 0,
@@ -708,7 +640,7 @@ function validateConfig() {
   }
 }
 
-// src/logger/adapters/custom.ts
+// src/logger/factory.ts
 function initializeTransports() {
   const transports = [];
   const consoleConfig = getConsoleConfig();
@@ -719,77 +651,15 @@ function initializeTransports() {
   }
   return transports;
 }
-var CustomAdapter = class _CustomAdapter {
-  logger;
-  constructor(config) {
-    this.logger = new Logger({
-      level: config.level,
-      module: config.module,
-      transports: initializeTransports()
-    });
-  }
-  child(module) {
-    const adapter = new _CustomAdapter({ level: this.logger.level, module });
-    adapter.logger = this.logger.child(module);
-    return adapter;
-  }
-  debug(message, context) {
-    this.logger.debug(message, context);
-  }
-  info(message, context) {
-    this.logger.info(message, context);
-  }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.warn(message, errorOrContext, context);
-    } else {
-      this.logger.warn(message, errorOrContext);
-    }
-  }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.error(message, errorOrContext, context);
-    } else {
-      this.logger.error(message, errorOrContext);
-    }
-  }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.fatal(message, errorOrContext, context);
-    } else {
-      this.logger.fatal(message, errorOrContext);
-    }
-  }
-  async close() {
-    await this.logger.close();
-  }
-};
-
-// src/logger/adapter-factory.ts
-function createAdapter(type) {
-  const level = getDefaultLogLevel();
-  switch (type) {
-    case "pino":
-      return new PinoAdapter({ level });
-    case "custom":
-      return new CustomAdapter({ level });
-    default:
-      return new PinoAdapter({ level });
-  }
-}
-function getAdapterType() {
-  const adapterEnv = process.env.LOGGER_ADAPTER;
-  if (adapterEnv === "custom" || adapterEnv === "pino") {
-    return adapterEnv;
-  }
-  return "pino";
-}
 function initializeLogger() {
   validateConfig();
-  return createAdapter(getAdapterType());
+  return new Logger({
+    level: getDefaultLogLevel(),
+    transports: initializeTransports()
+  });
 }
 var logger = initializeLogger();
 
-export { logger };
+export { Logger, logger };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map