feat: custom logger (#13156)

* feat: custom logger

* mock log

* unit test

* FF and jobs loader

* unit test

* add to ResourceLoader

* get from container

* mock

* rm log

* default logger mock

* link loaders, express

* comments

* initialize container as first step

* db conn

* test

* initialize start

* plugin build using default logger

* ignore .medusa

* revert ignroe

---------

Co-authored-by: Oli Juhl <[email protected]>

Author: carlos-r-l-rodrigues

.changeset/seven-pigs-build.md

@@ -0,0 +1,9 @@
+---
+"@medusajs/test-utils": patch
+"@medusajs/framework": patch
+"@medusajs/types": patch
+"@medusajs/utils": patch
+"@medusajs/medusa": patch
+---
+
+feat: custom logger on medusa-config

packages/core/framework/src/config/config.ts

@@ -1,6 +1,6 @@
-import { ConfigModule } from "./types"
 import { deepCopy, isDefined } from "@medusajs/utils"
 import { logger } from "../logger"
+import { ConfigModule } from "./types"
 
 export class ConfigManager {
   /**
@@ -124,21 +124,23 @@ export class ConfigManager {
 
   /**
    * Normalizes the project config object and assign the defaults if needed
-   * @param projectConfig
+   * @param config
    * @protected
    */
   protected normalizeProjectConfig(
-    projectConfig: Partial<ConfigModule["projectConfig"]>
+    config: Partial<ConfigModule>
   ): ConfigModule["projectConfig"] {
-    const outputConfig = deepCopy(
-      projectConfig
-    ) as ConfigModule["projectConfig"]
+    const projConfig = config?.projectConfig ?? {}
+    const outputConfig = deepCopy(projConfig) as ConfigModule["projectConfig"]
 
     if (!outputConfig?.redisUrl) {
-      console.log(`redisUrl not found. A fake redis instance will be used.`)
+      const customLogger = config?.logger ?? logger
+      customLogger.log(
+        `redisUrl not found. A fake redis instance will be used.`
+      )
     }
 
-    outputConfig.http = this.buildHttpConfig(projectConfig)
+    outputConfig.http = this.buildHttpConfig(projConfig)
 
     let workerMode = outputConfig?.workerMode!
 
@@ -172,9 +174,7 @@ export class ConfigManager {
   }): ConfigModule {
     this.#baseDir = baseDir
 
-    const normalizedProjectConfig = this.normalizeProjectConfig(
-      projectConfig.projectConfig ?? {}
-    )
+    const normalizedProjectConfig = this.normalizeProjectConfig(projectConfig)
 
     this.#config = {
       projectConfig: normalizedProjectConfig,
@@ -184,6 +184,7 @@ export class ConfigManager {
       modules: projectConfig.modules ?? {},
       featureFlags: projectConfig.featureFlags ?? {},
       plugins: projectConfig.plugins ?? [],
+      logger: projectConfig.logger ?? logger,
     }
 
     return this.#config

packages/core/framework/src/config/loader.ts

@@ -1,14 +1,14 @@
-import { ConfigModule } from "./types"
 import { ContainerRegistrationKeys, getConfigFile } from "@medusajs/utils"
-import { logger } from "../logger"
-import { ConfigManager } from "./config"
-import { container } from "../container"
 import { asFunction } from "awilix"
+import { container } from "../container"
+import { logger as defaultLogger } from "../logger"
+import { ConfigManager } from "./config"
+import { ConfigModule } from "./types"
 
 const handleConfigError = (error: Error): void => {
-  logger.error(`Error in loading config: ${error.message}`)
+  defaultLogger.error(`Error in loading config: ${error.message}`)
   if (error.stack) {
-    logger.error(error.stack)
+    defaultLogger.error(error.stack)
   }
   process.exit(1)
 }
@@ -28,7 +28,7 @@ container.register(
  */
 export async function configLoader(
   entryDirectory: string,
-  configFileName: string
+  configFileName: string = "medusa-config"
 ): Promise<ConfigModule> {
   const config = await getConfigFile<ConfigModule>(
     entryDirectory,

packages/core/framework/src/feature-flags/feature-flag-loader.ts

@@ -10,7 +10,6 @@ import { asFunction } from "awilix"
 import { normalize } from "path"
 import { configManager } from "../config"
 import { container } from "../container"
-import { logger } from "../logger"
 import { FlagSettings } from "./types"
 
 container.register(
@@ -25,7 +24,7 @@ container.register(
 export async function featureFlagsLoader(
   sourcePath?: string
 ): Promise<FlagRouter> {
-  const { featureFlags: projectConfigFlags = {} } = configManager.config
+  const { featureFlags: projectConfigFlags = {}, logger } = configManager.config
 
   if (!sourcePath) {
     return FeatureFlag

packages/core/framework/src/http/__fixtures__/server/index.ts

@@ -3,17 +3,16 @@ import {
   ModulesDefinition,
   registerMedusaModule,
 } from "@medusajs/modules-sdk"
+import { MedusaContainer } from "@medusajs/types"
 import { ContainerRegistrationKeys, generateJwtToken } from "@medusajs/utils"
 import { asValue } from "awilix"
 import express from "express"
 import querystring from "querystring"
 import supertest from "supertest"
-
-import { MedusaContainer } from "@medusajs/types"
 import { configManager } from "../../../config"
 import { container } from "../../../container"
 import { featureFlagsLoader } from "../../../feature-flags"
-import { logger } from "../../../logger"
+import { logger as defaultLogger } from "../../../logger"
 import { ApiLoader } from "../../router"
 import { MedusaRequest } from "../../types"
 import { config } from "../mocks"
@@ -66,11 +65,8 @@ export const createServer = async (rootDir) => {
 
   container.register(ContainerRegistrationKeys.PG_CONNECTION, asValue({}))
   container.register("configModule", asValue(config))
+  container.register(ContainerRegistrationKeys.LOGGER, asValue(defaultLogger))
   container.register({
-    logger: asValue({
-      error: () => {},
-      info: () => {},
-    }),
     manager: asValue({}),
   })
 
@@ -88,7 +84,7 @@ export const createServer = async (rootDir) => {
   })
 
   await featureFlagsLoader()
-  await moduleLoader({ container, moduleResolutions, logger })
+  await moduleLoader({ container, moduleResolutions, logger: defaultLogger })
 
   app.use((req, res, next) => {
     ;(req as MedusaRequest).scope = container.createScope() as MedusaContainer
@@ -98,6 +94,7 @@ export const createServer = async (rootDir) => {
   await new ApiLoader({
     app,
     sourceDir: rootDir,
+    container,
   }).load()
 
   const superRequest = supertest(app)

packages/core/framework/src/http/__tests__/index.spec.ts

@@ -1,13 +1,19 @@
+import {
+  ContainerRegistrationKeys,
+  createMedusaContainer,
+} from "@medusajs/utils"
+import { asValue } from "awilix"
 import express from "express"
 import { resolve } from "path"
+import { logger as defaultLogger } from "../../logger"
 import {
   customersCreateMiddlewareMock,
   customersCreateMiddlewareValidatorMock,
   customersGlobalMiddlewareMock,
   storeGlobalMiddlewareMock,
 } from "../__fixtures__/mocks"
 import { createServer } from "../__fixtures__/server"
-import { MedusaNextFunction, ApiLoader } from "../index"
+import { ApiLoader, MedusaNextFunction } from "../index"
 
 jest.setTimeout(30000)
 
@@ -335,9 +341,16 @@ describe("RoutesLoader", function () {
         __dirname,
         "../__fixtures__/routers-duplicate-parameter"
       )
+      const container = createMedusaContainer()
+      container.register(
+        ContainerRegistrationKeys.LOGGER,
+        asValue(defaultLogger)
+      )
+
       const err = await new ApiLoader({
         app,
         sourceDir: rootDir,
+        container,
       })
         .load()
         .catch((e) => e)

packages/core/framework/src/http/express-loader.ts

@@ -1,3 +1,5 @@
+import { MedusaContainer } from "@medusajs/framework/types"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
 import { dynamicImport } from "@medusajs/utils"
 import createStore from "connect-redis"
 import cookieParser from "cookie-parser"
@@ -7,14 +9,19 @@ import Redis from "ioredis"
 import morgan from "morgan"
 import path from "path"
 import { configManager } from "../config"
-import { logger } from "../logger"
 import { MedusaRequest, MedusaResponse } from "./types"
 
 const NOISY_ENDPOINTS_CHUNKS = ["@fs", "@id", "@vite", "@react", "node_modules"]
 
 const isHealthCheck = (req: MedusaRequest) => req.path === "/health"
 
-export async function expressLoader({ app }: { app: Express }): Promise<{
+export async function expressLoader({
+  app,
+  container,
+}: {
+  app: Express
+  container: MedusaContainer
+}): Promise<{
   app: Express
   shutdown: () => Promise<void>
 }> {
@@ -25,6 +32,7 @@ export async function expressLoader({ app }: { app: Express }): Promise<{
   const IS_DEV = NODE_ENV.startsWith("dev")
   const isStaging = NODE_ENV === "staging"
   const isTest = NODE_ENV === "test"
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER)
 
   let sameSite: string | boolean = false
   let secure = false

packages/core/framework/src/http/router.ts

@@ -1,31 +1,31 @@
-import logger from "@medusajs/cli/dist/reporter"
+import { ContainerRegistrationKeys, parseCorsOrigins } from "@medusajs/utils"
 import cors, { CorsOptions } from "cors"
-import { parseCorsOrigins } from "@medusajs/utils"
-import type { Express, RequestHandler, ErrorRequestHandler } from "express"
+import type { ErrorRequestHandler, Express, RequestHandler } from "express"
 import type {
+  AdditionalDataValidatorRoute,
+  BodyParserConfigRoute,
+  MedusaNextFunction,
   MedusaRequest,
   MedusaResponse,
+  MiddlewareDescriptor,
+  MiddlewareFunction,
   MiddlewareVerb,
   RouteDescriptor,
-  MiddlewareFunction,
-  MedusaNextFunction,
-  MiddlewareDescriptor,
-  BodyParserConfigRoute,
   RouteHandler,
-  AdditionalDataValidatorRoute,
 } from "./types"
 
-import { RoutesLoader } from "./routes-loader"
-import { RoutesFinder } from "./routes-finder"
-import { RoutesSorter } from "./routes-sorter"
-import { wrapHandler } from "./utils/wrap-handler"
-import { authenticate, AuthType } from "./middlewares"
-import { errorHandler } from "./middlewares/error-handler"
-import { RestrictedFields } from "./utils/restricted-fields"
+import { Logger, MedusaContainer } from "@medusajs/types"
+import { configManager } from "../config"
 import { MiddlewareFileLoader } from "./middleware-file-loader"
+import { authenticate, AuthType } from "./middlewares"
 import { createBodyParserMiddlewaresStack } from "./middlewares/bodyparser"
 import { ensurePublishableApiKeyMiddleware } from "./middlewares/ensure-publishable-api-key"
-import { configManager } from "../config"
+import { errorHandler } from "./middlewares/error-handler"
+import { RoutesFinder } from "./routes-finder"
+import { RoutesLoader } from "./routes-loader"
+import { RoutesSorter } from "./routes-sorter"
+import { RestrictedFields } from "./utils/restricted-fields"
+import { wrapHandler } from "./utils/wrap-handler"
 
 export class ApiLoader {
   /**
@@ -58,18 +58,23 @@ export class ApiLoader {
    */
   readonly #sourceDirs: string[]
 
+  readonly #logger: Logger
+
   constructor({
     app,
     sourceDir,
     baseRestrictedFields = [],
+    container,
   }: {
     app: Express
     sourceDir: string | string[]
     baseRestrictedFields?: string[]
+    container: MedusaContainer
   }) {
     this.#app = app
     this.#sourceDirs = Array.isArray(sourceDir) ? sourceDir : [sourceDir]
     this.#assignRestrictedFields(baseRestrictedFields ?? [])
+    this.#logger = container.resolve(ContainerRegistrationKeys.LOGGER)
   }
 
   /**
@@ -105,7 +110,7 @@ export class ApiLoader {
     route: MiddlewareDescriptor | RouteDescriptor | RouteDescriptor
   ) {
     if ("isRoute" in route) {
-      logger.debug(`registering route ${route.method} ${route.matcher}`)
+      this.#logger.debug(`registering route ${route.method} ${route.matcher}`)
       const handler = ApiLoader.traceRoute
         ? ApiLoader.traceRoute(route.handler, {
             route: route.matcher,
@@ -118,7 +123,7 @@ export class ApiLoader {
     }
 
     if (!route.methods) {
-      logger.debug(`registering global middleware for ${route.matcher}`)
+      this.#logger.debug(`registering global middleware for ${route.matcher}`)
       const handler = ApiLoader.traceMiddleware
         ? (ApiLoader.traceMiddleware(route.handler, {
             route: route.matcher,
@@ -133,7 +138,9 @@ export class ApiLoader {
       ? route.methods
       : [route.methods]
     methods.forEach((method) => {
-      logger.debug(`registering route middleware ${method} ${route.matcher}`)
+      this.#logger.debug(
+        `registering route middleware ${method} ${route.matcher}`
+      )
       const handler = ApiLoader.traceMiddleware
         ? (ApiLoader.traceMiddleware(wrapHandler(route.handler), {
             route: route.matcher,
@@ -192,6 +199,7 @@ export class ApiLoader {
       | "shouldAppendStoreCors",
     corsOptions: CorsOptions
   ) {
+    const logger = this.#logger
     const corsFn = cors(corsOptions)
     const corsMiddleware: RequestHandler = function corsMiddleware(
       req,
@@ -234,6 +242,7 @@ export class ApiLoader {
     authType: AuthType | AuthType[],
     options?: { allowUnauthenticated?: boolean; allowUnregistered?: boolean }
   ) {
+    const logger = this.#logger
     logger.debug(`Registering auth middleware for prefix ${namespace}`)
 
     const originalFn = authenticate(actorType, authType, options)
@@ -273,7 +282,9 @@ export class ApiLoader {
     namespace: string,
     routesFinder: RoutesFinder<BodyParserConfigRoute>
   ): void {
-    logger.debug(`Registering bodyparser middleware for prefix ${namespace}`)
+    this.#logger.debug(
+      `Registering bodyparser middleware for prefix ${namespace}`
+    )
     this.#app.use(
       namespace,
       createBodyParserMiddlewaresStack(
@@ -292,6 +303,7 @@ export class ApiLoader {
     namespace: string,
     routesFinder: RoutesFinder<AdditionalDataValidatorRoute>
   ) {
+    const logger = this.#logger
     logger.debug(
       `Registering assignAdditionalDataValidator middleware for prefix ${namespace}`
     )
@@ -329,7 +341,7 @@ export class ApiLoader {
    * a `x-publishable-key` header
    */
   #applyStorePublishableKeyMiddleware(namespace: string) {
-    logger.debug(
+    this.#logger.debug(
       `Registering publishable key middleware for namespace ${namespace}`
     )
     let middleware = ApiLoader.traceMiddleware