@axiom-lattice/core 2.1.14 → 2.1.15

package/dist/index.mjs

@@ -5237,6 +5237,323 @@ var registerVectorStoreLattice = (key, vectorStore) => vectorStoreLatticeManager
 var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLattice(key);
 var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
 
+// src/logger_lattice/LoggerLatticeManager.ts
+import {
+  LoggerType
+} from "@axiom-lattice/protocols";
+
+// src/logger_lattice/PinoLoggerClient.ts
+import pino from "pino";
+import "pino-pretty";
+import "pino-roll";
+var PinoLoggerClient = class _PinoLoggerClient {
+  constructor(config) {
+    this.config = config;
+    this.context = config.context || {};
+    const loggerConfig = {
+      // Custom timestamp format
+      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+      // Base metadata
+      base: {
+        "@version": "1",
+        app_name: "lattice",
+        service_name: config.serviceName || "lattice-service",
+        thread_name: "main",
+        logger_name: config.loggerName || config.name || "lattice-logger"
+      },
+      formatters: {
+        level: (label, number) => {
+          return {
+            level: label.toUpperCase(),
+            level_value: number * 1e3
+          };
+        }
+      }
+    };
+    const useFileLogging = this.shouldUseFileLogging(config);
+    const fileOptions = this.getFileOptions(config);
+    if (useFileLogging && fileOptions) {
+      try {
+        this.pinoLogger = pino(
+          loggerConfig,
+          pino.transport({
+            target: "pino-roll",
+            options: {
+              file: fileOptions.file || "./logs/app",
+              frequency: fileOptions.frequency || "daily",
+              mkdir: fileOptions.mkdir !== false,
+              // Default to true
+              size: fileOptions.size,
+              maxFiles: fileOptions.maxFiles
+            }
+          })
+        );
+      } catch (error) {
+        console.error(
+          "Failed to initialize pino-roll logger, falling back to console",
+          error
+        );
+        this.pinoLogger = pino({
+          ...loggerConfig,
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true
+            }
+          }
+        });
+      }
+    } else {
+      this.pinoLogger = pino({
+        ...loggerConfig,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Determine if file logging should be used
+   */
+  shouldUseFileLogging(config) {
+    const hasFileConfig = config.file !== void 0;
+    const isProduction = process.env.NODE_ENV === "production";
+    return hasFileConfig || isProduction;
+  }
+  /**
+   * Get file options from config
+   */
+  getFileOptions(config) {
+    if (!config.file) {
+      if (process.env.NODE_ENV === "production") {
+        return {
+          file: "./logs/app",
+          frequency: "daily",
+          mkdir: true
+        };
+      }
+      return null;
+    }
+    if (typeof config.file === "string") {
+      return {
+        file: config.file,
+        frequency: "daily",
+        mkdir: true
+      };
+    }
+    return config.file;
+  }
+  /**
+   * Get contextual logger with merged context
+   */
+  getContextualLogger(additionalContext) {
+    const contextObj = {
+      "x-user-id": this.context["x-user-id"] || "",
+      "x-tenant-id": this.context["x-tenant-id"] || "",
+      "x-request-id": this.context["x-request-id"] || "",
+      "x-thread-id": this.context["x-thread-id"] || "",
+      service_name: this.config.serviceName || "lattice-service",
+      logger_name: this.config.loggerName || this.config.name || "lattice-logger",
+      ...additionalContext
+    };
+    return this.pinoLogger.child(contextObj);
+  }
+  info(msg, obj) {
+    this.getContextualLogger(obj).info(msg);
+  }
+  error(msg, obj) {
+    this.getContextualLogger(obj).error(msg);
+  }
+  warn(msg, obj) {
+    this.getContextualLogger(obj).warn(msg);
+  }
+  debug(msg, obj) {
+    this.getContextualLogger(obj).debug(msg);
+  }
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  child(options) {
+    return new _PinoLoggerClient({
+      ...this.config,
+      ...options,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+  }
+};
+
+// src/logger_lattice/ConsoleLoggerClient.ts
+var ConsoleLoggerClient = class _ConsoleLoggerClient {
+  constructor(config) {
+    this.config = config;
+    this.context = config.context || {};
+  }
+  formatMessage(level, msg, obj) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const contextStr = Object.keys(this.context).length > 0 ? ` [${JSON.stringify(this.context)}]` : "";
+    const objStr = obj ? ` ${JSON.stringify(obj)}` : "";
+    return `[${timestamp}] [${level}]${contextStr} ${msg}${objStr}`;
+  }
+  info(msg, obj) {
+    console.log(this.formatMessage("INFO", msg, obj));
+  }
+  error(msg, obj) {
+    console.error(this.formatMessage("ERROR", msg, obj));
+  }
+  warn(msg, obj) {
+    console.warn(this.formatMessage("WARN", msg, obj));
+  }
+  debug(msg, obj) {
+    console.debug(this.formatMessage("DEBUG", msg, obj));
+  }
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  child(options) {
+    const childClient = new _ConsoleLoggerClient({
+      ...this.config,
+      ...options,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+    return childClient;
+  }
+};
+
+// src/logger_lattice/LoggerLatticeManager.ts
+var LoggerLatticeManager = class _LoggerLatticeManager extends BaseLatticeManager {
+  /**
+   * Get LoggerLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_LoggerLatticeManager._instance) {
+      _LoggerLatticeManager._instance = new _LoggerLatticeManager();
+    }
+    return _LoggerLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "loggers";
+  }
+  /**
+   * Register logger Lattice
+   * @param key Lattice key name
+   * @param config Logger configuration
+   * @param client Optional logger client. If not provided, will create based on config type.
+   */
+  registerLattice(key, config, client) {
+    let loggerClient;
+    if (client) {
+      loggerClient = client;
+    } else {
+      if (config.type === LoggerType.PINO) {
+        loggerClient = new PinoLoggerClient(config);
+      } else if (config.type === LoggerType.CONSOLE) {
+        loggerClient = new ConsoleLoggerClient(config);
+      } else if (config.type === LoggerType.CUSTOM) {
+        throw new Error(
+          `Custom logger client must be provided. Please pass the client to registerLattice.`
+        );
+      } else {
+        loggerClient = new PinoLoggerClient(config);
+      }
+    }
+    const loggerLattice = {
+      key,
+      config,
+      client: loggerClient,
+      // Logger operations
+      info: (msg, obj) => {
+        loggerClient.info(msg, obj);
+      },
+      error: (msg, obj) => {
+        loggerClient.error(msg, obj);
+      },
+      warn: (msg, obj) => {
+        loggerClient.warn(msg, obj);
+      },
+      debug: (msg, obj) => {
+        loggerClient.debug(msg, obj);
+      },
+      updateContext: loggerClient.updateContext ? (context) => {
+        loggerClient.updateContext(context);
+      } : void 0,
+      child: loggerClient.child ? (options) => {
+        return loggerClient.child(options);
+      } : void 0
+    };
+    this.register(key, loggerLattice);
+  }
+  /**
+   * Get LoggerLattice
+   * @param key Lattice key name
+   */
+  getLoggerLattice(key) {
+    const loggerLattice = this.get(key);
+    if (!loggerLattice) {
+      throw new Error(`LoggerLattice ${key} not found`);
+    }
+    return loggerLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var loggerLatticeManager = LoggerLatticeManager.getInstance();
+var registerLoggerLattice = (key, config, client) => loggerLatticeManager.registerLattice(key, config, client);
+var getLoggerLattice = (key) => loggerLatticeManager.getLoggerLattice(key);
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 export {
@@ -5247,17 +5564,20 @@ export {
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
+  ConsoleLoggerClient,
   DefaultScheduleClient,
   EmbeddingsLatticeManager,
   GraphBuildOptions,
   InMemoryAssistantStore,
   InMemoryChunkBuffer,
   InMemoryThreadStore,
+  LoggerLatticeManager,
   MemoryLatticeManager,
   MemoryQueueClient,
   MemoryScheduleStorage,
   MemoryType,
   ModelLatticeManager,
+  PinoLoggerClient,
   PostgresDatabase,
   Protocols,
   QueueLatticeManager,
@@ -5281,6 +5601,7 @@ export {
   getChunkBuffer,
   getEmbeddingsClient,
   getEmbeddingsLattice,
+  getLoggerLattice,
   getModelLattice,
   getNextCronTime,
   getQueueLattice,
@@ -5293,6 +5614,7 @@ export {
   getVectorStoreLattice,
   hasChunkBuffer,
   isValidCronExpression,
+  loggerLatticeManager,
   modelLatticeManager,
   parseCronExpression,
   queueLatticeManager,
@@ -5301,6 +5623,7 @@ export {
   registerCheckpointSaver,
   registerChunkBuffer,
   registerEmbeddingsLattice,
+  registerLoggerLattice,
   registerModelLattice,
   registerQueueLattice,
   registerScheduleLattice,