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

package/dist/db/index.d.ts

@@ -189,6 +189,7 @@ declare function setDatabase(write: PostgresJsDatabase<Record<string, unknown>>
  * - DB_MONITORING_ENABLED (enable query monitoring, default: true in dev, false in prod)
  * - DB_MONITORING_SLOW_THRESHOLD (slow query threshold in ms, default: 1000)
  * - DB_MONITORING_LOG_QUERIES (log actual SQL queries, default: false)
+ * - DB_DEBUG_TRACE (enable detailed getDatabase() call tracing with caller info, default: false)
  *
  * Configuration priority:
  * 1. options parameter (ServerConfig)

package/dist/db/index.js

@@ -1,6 +1,5 @@
 import { drizzle } from 'drizzle-orm/postgres-js';
-import pino from 'pino';
-import { existsSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, statSync, readdirSync, renameSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, createWriteStream, statSync, readdirSync, renameSync, unlinkSync, accessSync, constants, writeFileSync, readFileSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { config } from 'dotenv';
 import postgres from 'postgres';
@@ -11,50 +10,6 @@ import { createMiddleware } from 'hono/factory';
 import { eq, and } from 'drizzle-orm';
 
 // src/db/manager/factory.ts
-var PinoAdapter = class _PinoAdapter {
-  logger;
-  constructor(config) {
-    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 = {
@@ -695,7 +650,7 @@ function validateConfig() {
   }
 }
 
-// src/logger/adapters/custom.ts
+// src/logger/factory.ts
 function initializeTransports() {
   const transports = [];
   const consoleConfig = getConsoleConfig();
@@ -706,74 +661,12 @@ 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();
 
@@ -1473,10 +1366,44 @@ function stopHealthCheck() {
 
 // src/db/manager/manager.ts
 var dbLogger4 = logger.child("database");
+function getCallerInfo() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) return void 0;
+    const lines = stack.split("\n");
+    for (let i = 3; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes("node_modules") && !line.includes("/db/manager/")) {
+        const match = line.match(/\((.+):(\d+):(\d+)\)/) || line.match(/at (.+):(\d+):(\d+)/);
+        if (match) {
+          const fullPath = match[1];
+          const parts = fullPath.split("/");
+          const srcIndex = parts.lastIndexOf("src");
+          if (srcIndex !== -1) {
+            const relativePath = parts.slice(srcIndex).join("/");
+            return `${relativePath}:${match[2]}`;
+          }
+          return `${fullPath}:${match[2]}`;
+        }
+        break;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
 function getDatabase(type) {
   const writeInst = getWriteInstance();
   const readInst = getReadInstance();
-  dbLogger4.debug(`getDatabase() called with type=${type}, writeInstance=${!!writeInst}, readInstance=${!!readInst}`);
+  if (process.env.DB_DEBUG_TRACE === "true") {
+    const caller = getCallerInfo();
+    dbLogger4.debug("getDatabase() called", {
+      type: type || "write",
+      hasWrite: !!writeInst,
+      hasRead: !!readInst,
+      caller
+    });
+  }
   if (type === "read") {
     return readInst ?? writeInst;
   }