Better logging

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@node-in-layers/core",
   "type": "module",
-  "version": "1.2.9",
+  "version": "1.4.3",
   "description": "The core library for the Node In Layers rapid web development framework.",
   "main": "index.js",
   "scripts": {
@@ -82,7 +82,7 @@
   "dependencies": {
     "async-lock": "^1.4.1",
     "axios": "^1.7.9",
-    "functional-models": "^3.0.12",
+    "functional-models": "^3.0.15",
     "import-meta-resolve": "^4.1.0",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.2",

src/entries.ts

@@ -28,6 +28,7 @@ const loadSystem = async <TConfig extends Config = Config>(args: {
   )
 
   const layersServices = layersApp.services.create()
+  // @ts-ignore
   const layersFeatures = layersApp.features.create({
     ...globals,
     services: {

src/globals/index.ts

@@ -1,4 +1,5 @@
 import merge from 'lodash/merge.js'
+import { v4 } from 'uuid'
 import get from 'lodash/get.js'
 import { isConfig, validateConfig } from '../libs.js'
 import {
@@ -16,12 +17,14 @@ const name = CoreNamespace.globals
 type GlobalsServicesProps = Readonly<{
   environment: string
   workingDirectory: string
+  runtimeId?: string
 }>
 
 type GlobalsServices<TConfig extends Config> = Readonly<{
   loadConfig: () => Promise<TConfig>
   getRootLogger: () => RootLogger
   getConstants: () => {
+    runtimeId: string
     workingDirectory: string
     environment: string
   }
@@ -41,13 +44,14 @@ const services = {
   create: <TConfig extends Config>({
     environment,
     workingDirectory,
+    runtimeId,
   }: GlobalsServicesProps): GlobalsServices<TConfig> => {
     const getRootLogger = standardLogger
 
     const _findConfigPath = async () => {
       const nodeFS = await import('node:fs')
       const nodePath = await import('node:path')
-      const extensions = ['mjs', 'js']
+      const extensions = ['mjs', 'js', 'mts', 'ts']
       return extensions
         .map(e => {
           return nodePath.resolve(
@@ -64,7 +68,7 @@ const services = {
       const fullPath = await _findConfigPath()
       if (!fullPath) {
         throw new Error(
-          `Could not find a config.${environment} for mjs, or js.`
+          `Could not find a config.${environment} for mts, ts, mjs, or js.`
         )
       }
       const url = new URL(`file://${fullPath}`)
@@ -81,6 +85,7 @@ const services = {
 
     const getConstants = () => {
       return {
+        runtimeId: runtimeId || v4(),
         workingDirectory,
         environment,
       }
@@ -122,7 +127,7 @@ const features = {
 
       const commonGlobals = {
         config,
-        log: ourServices.getRootLogger(),
+        rootLogger: ourServices.getRootLogger(),
         constants: ourServices.getConstants(),
       }
       const globals: TGlobals = await config[CoreNamespace.root].apps.reduce(

src/globals/lib.ts

@@ -0,0 +1,74 @@
+import merge from 'lodash/merge.js'
+import get from 'lodash/get.js'
+import omit from 'lodash/omit.js'
+import { LogLevelNames, CrossLayerProps, Logger, LogId } from '../types.js'
+
+const defaultGetFunctionWrapLogLevel = (layerName: string): LogLevelNames => {
+  switch (layerName) {
+    case 'features':
+    case 'entries':
+      return LogLevelNames.info
+    case 'services':
+      return LogLevelNames.trace
+    default:
+      return LogLevelNames.debug
+  }
+}
+
+/**
+ * Gets the cross layer props and combines it with information from the logger.
+ * Does this in a "smart" way.
+ *
+ * The result of this can be dumped directly into applyData.
+ *
+ * @param {Logger} logger
+ * @param {CrossLayerProps} crossLayerProps
+ */
+const combineLoggingProps = (
+  logger: Logger,
+  crossLayerProps?: CrossLayerProps
+) => {
+  const loggingData = crossLayerProps?.logging || {}
+  const ids = loggingData.ids || []
+  const currentIds = logger.getIds()
+  const existingIds = currentIds.reduce(
+    (acc, obj) => {
+      return Object.keys(obj).reduce((accKeys, key) => {
+        return merge(accKeys, { [key]: key })
+      }, acc)
+    },
+    {} as Record<string, string>
+  )
+  const unique = ids.reduce(
+    (acc, passedIn) => {
+      const keys = Object.entries(passedIn)
+      const newKeys = keys
+        .filter(([, value]) => !(value in existingIds))
+        .map(([key, value]) => ({ [key]: value }))
+      if (newKeys.length > 0) {
+        return acc.concat(newKeys)
+      }
+      return acc
+    },
+    [] as readonly LogId[]
+  )
+
+  return merge(
+    {
+      ids: logger.getIds().concat(unique),
+    },
+    omit(loggingData, 'ids')
+  )
+}
+
+const isCrossLayerLoggingProps = (
+  maybe?: CrossLayerProps
+): maybe is CrossLayerProps => {
+  return Boolean(get(maybe, 'logging.ids'))
+}
+
+export {
+  defaultGetFunctionWrapLogLevel,
+  combineLoggingProps,
+  isCrossLayerLoggingProps,
+}